Discussion :

[lulu7]

Bonjour, alors voila mon problème, je cherche désespérément un moyen de partager un objet entre 2 processus (avec le multi-processing).
Je ne trouve rien sur le net de très concluant, j'ai pu trouver 2-3 tentative de bidouilles sur stackoverflow, mais sa ne semble pas marcher.

Voici toute mes questions :

1) Es ce possible de faire cela en python ?
2) Si oui l'avez vous déja fait ?
3) si oui, pouvez vous me montrer comment ?

Pour le partage de variable en revanche j'arrive à partager des int, float, char et co avec c_types :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
variablepartager = Value('i', 0)
variablepartager.value=10 #je change sa valeur à 10
proc = multiprocessing.Process(target=StartProgramme, args=(variablepartager,))
proc.start()

4) sa marche bien, mais c'est tres gourmand en mémoire, variablepartager me consomme 50mo de ram ! y'a t'il moyen de baisser sa consommation de manière plus raisonnable ?

pour l'array voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
data=[[0,0],[1,1]]
dataArray=Array(ctypes.c_int, [elt for row in data for elt in row], lock=False)
 
def _initialize_subprocess(shared_array_base):
	test.shared_array_base = shared_array_base
 
with Pool(processes=None, initializer=_initialize_subprocess, initargs=(dataArray,)) as pool:
   pool.starmap(StartProcess, [(,)])

5) Grosse limitation la aussi, car on peut partager un array 1D, mais comment on fait si on a une matrice 2D ?

Voila, merci d'avance pour vos réponses à ces question.
Je suis sous python 3.5 64bits sous windows 7 pro

[RyzenOC]

à ma connaissance il est impossible de partager en mémoire un objet entre 2 processus.

C'est pas pratique, mais faudra utiliser des socket ou pickle.
Y'a peut être moyen avec Marshall, j'ai jamais essayé ? mashall peut sérialiser un objet dans la ram je pense que sa sera plus performant que pickle dans l'éventualité ou l'on pourra partager la variable en mémoire.

Pour le reste :
Utiliser Value c'est tres pratique (partage en mémoire automatique) mais c'est très consommateur, tu ne pourra rien y faire.
Seul solution passer par la sériéalisation ou des socket, on revient donc au point de départ

Pour ton array, impossible de partager un array n dimension
Il te faudra un array avec tes data et un 2eme array contenant la taille de chaque colonnes, c'est pas pratique je sais.
Value ne prend en charge que les c_type (int, float, double, char...) je ne croit pas que l'on puisse y mettre un tableau 2D

Tes questions soulève le gros point noir de python, pas conçue pour le multicore, on utilise un hack appeler multi-processing mais sa impose de grosse limitations en matière d’interaction entre les process (pas de partage mémoire possible)

[wiztricks]

Tes questions soulève le gros point noir de python, pas conçue pour le multicore, on utilise un hack appeler multi-processing mais sa impose de grosse limitations en matière d’interaction entre les process (pas de partage mémoire possible)

Il n'y a pas de problème pour partager de la mémoire. Vous pouvez même le faire avec mmap. Le problème est que "la mémoire" est une abstraction de très bas niveau comparée a ce que sont des objets Python. Notez que si vous voulez partager des objets Java ou C++ entre deux "process" vous avez le même problème.

- W

[RyzenOC]

En java on utilise les threads directement, pas de multi-processing.

[wiztricks]

pouvez vous m'en dire plus sur les mmap ?

sur la page officiel : https://docs.python.org/2/library/mmap.html
rien ne semble indiquer que l'on puisse utiliser un objet sur plusieurs process.

Relisez ce que j'ai écrit. J'ai bien pris la peine de distinguer "mémoire" et "objets Pythons".

- W

[lulu7]

Il n'y a pas de problème pour partager de la mémoire. Vous pouvez même le faire avec mmap. Le problème est que "la mémoire" est une abstraction de très bas niveau comparée a ce que sont des objets Python. Notez que si vous voulez partager des objets Java ou C++ entre deux "process" vous avez le même problème.

pouvez vous m'en dire plus sur les mmap ?

sur la page officiel : https://docs.python.org/2/library/mmap.html
rien ne semble indiquer que l'on puisse utiliser un objet sur plusieurs process.

[wiztricks]

Salut,

Bonjour, alors voila mon problème, je cherche désespérément un moyen de partager un objet entre 2 processus (avec le multi-processing).
Je ne trouve rien sur le net de très concluant, j'ai pu trouver 2-3 tentative de bidouilles sur stackoverflow, mais sa ne semble pas marcher.

Voici toute mes questions :

1) Es ce possible de faire cela en python ?
2) Si oui l'avez vous déja fait ?
3) si oui, pouvez vous me montrer comment ?

La documentation du module multiprocessing donne exemples et explications: pas besoin de chercher partout pour les recopier, les essayer, les adapter.

4) sa marche bien, mais c'est tres gourmand en mémoire, variablepartager me consomme 50mo de ram ! y'a t'il moyen de baisser sa consommation de manière plus raisonnable ?

Voir la deuxième partie de cette discussion.

5) Grosse limitation la aussi, car on peut partager un array 1D, mais comment on fait si on a une matrice 2D ?

Le système d'exploitation permet à des process de partager une portion de leur espace virtuel via la fonctionnalité mmap. C'est juste un tableau d'octets qu'on peut regrouper par paquets de 2/4/8 pour avoir différents types d'entiers, float, double. Ca reste basique mais tout ce que vous voulez en plus d'un tableau de longueur N avec des éléments de taille fixe seront des fonctionnalités supplémentaires permettant à l'utilisateur d'avoir l'illusion que c'est plus qu'un tableau 1D.
note: un tableau 2D, c'est juste un tableau 1D avec une fonction (i, j) ---> N.
numpy et autres modules additionnels font déjà ce boulot pour vous.

- W

[lulu7]

merci pour vos réponses :

note: un tableau 2D, c'est juste un tableau 1D avec une fonction (i, j) ---> N.
numpy et autres modules additionnels font déjà ce boulot pour vous.

Oui mais seul Array permet de partager un tableau en mémoire, je n'ai pas vue de cas avec numpy (et une matrice 2d donc)

La documentation du module multiprocessing donne exemples et explications: pas besoin de chercher partout pour les recopier, les essayer, les adapter.

Les exemples ne font pas vraiment ce que je cherche, voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class Monobjet(self, var1):
	self.var1=var1
 
	def function1(self):
		self.var1=self.var1+2
 
	def function2(self):
		self.var1=self.var1+6	
 
	def function3(self):
		print(self.var1)

j'aimerais instancier mon objet, avec var1=0 (par exemple)
puis dans 1 process lancer la fonction function1 et dans un autre process lancer function2, les 2 devrosn tourner en parallèle.
et pour finir lancer function3.

Dans cette exemple je fais abstraction du lock (peut importe si function1 se lance en 1er ou pas) c'est pas ce qui m'interesse (j'utiliserais des .join() si besoin)

[RyzenOC]

l'exemple qui se raproche de ce que tu cherche c'est celui avec les managers :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
from multiprocessing.managers import BaseManager
 
class MathsClass:
    def add(self, x, y):
        return x + y
    def mul(self, x, y):
        return x * y
 
class MyManager(BaseManager):
    pass
 
MyManager.register('Maths', MathsClass)
 
if __name__ == '__main__':
    with MyManager() as manager:
        maths = manager.Maths()
        print(maths.add(4, 3))
        print(maths.mul(7, 8))

mais les calcules ne sont pas lancé en parallèles.

[wiztricks]

Les exemples ne font pas vraiment ce que je cherche, voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class Monobjet(self, var1):
	self.var1=var1
 
	def function1(self):
		self.var1=self.var1+2
 
	def function2(self):
		self.var1=self.var1+6	
 
	def function3(self):
		print(self.var1)

j'aimerais instancier mon objet, avec var1=0 (par exemple)
puis dans 1 process lancer la fonction function1 et dans un autre process lancer function2, les 2 devrosn tourner en parallèle.
et pour finir lancer function3.

Tel que, vos fonctions ne font pas grand chose.
Vous devriez peut être faire un exemple un peu plus fonctionnel avec des Threads.
Ca permettrait de poser le problème pour voir comment obtenir les mêmes résultats avec multiprocessing.

- W

[lulu7]

voici un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
import numpy
import threading 
 
class DataManager:
	def __init__(self):
		self.data= numpy.random.randn(10000, 10000)
	def mean(self):
		self.data_mean=self.data.mean(axis=0)
		print(self.data_mean)
	def median(self):
		self.data_median=self.data.std()
		print(self.data_median)
 
test=DataManager()
 
a =threading.Thread(test.median())
b =threading.Thread(test.mean())
a.start() 
b.start()

J'aimerais lancer les 2 méthodes de mon objets en parallèle sur 2 core de cpu.

[wiztricks]

Salut,

Bah vu le pas grand chose que fait votre code "fonctionellement équivalent" se réduit à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import numpy as np
import multiprocessing as mp
import ctypes 
 
class DataManager:
    def __init__(self, N=10):
        sa = self.shared_data = mp.Array(ctypes.c_double, N*N)
        data = np.frombuffer(sa.get_obj(), dtype=np.float)
        data = data.reshape((N, N))
        self.data = data[:] = np.random.randn(N, N)
 
    def mean(self):
        print('mean', self.data.mean(axis=0))
 
    def median(self):
        print('median', self.data.std())
 
if __name__ == '__main__':
    test=DataManager()
 
    a = mp.Process(target = test.median)
    b = mp.Process(target = test.mean)
    a.start() 
    b.start()
    a.join()
    b.join()

Et encore, je suis gentil car j'aurais pu me contenter d'écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import numpy
import multiprocessing
 
class DataManager:
	def __init__(self):
		self.data= numpy.random.randn(10000, 10000)
	def mean(self):
		self.data_mean=self.data.mean(axis=0)
		print(self.data_mean)
	def median(self):
		self.data_median=self.data.std()
		print(self.data_median)
 
test=DataManager()
test.median()
test.mean()

car c'est aussi "fonctionellement équivalent" (au code que vous avez posté).

note: à partir du moment ou objets partagés n'existent pas, on va être obligé de construire une solution adaptée à chaque cas. Problème simple solution triviale, problème compliqué mise en œuvre de bibliothèques tierces adaptées ou on va mixer le support des données entre mémoire partagée et "messages" de mises à jour d'objets "partagées" via un Manager.

- W