Partager des objets en mémoire

**lulu7** · 01/08/2016, 17h29

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** · 01/08/2016, 18h34

à 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** · 01/08/2016, 18h45

Salut,

Envoyé par 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 ?

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

Envoyé par lulu7

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.

Envoyé par lulu7

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** · 01/08/2016, 19h09

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** · 01/08/2016, 19h18

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** · 01/08/2016, 19h27

Envoyé par sazearte

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** · 01/08/2016, 20h11

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

**lulu7** · 01/08/2016, 20h13

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** · 01/08/2016, 20h15

Envoyé par sazearte

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

**wiztricks** · 01/08/2016, 20h18

Envoyé par lulu7

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** · 01/08/2016, 21h16

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** · 02/08/2016, 10h48

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

**lulu7** · 02/08/2016, 11h01

Merci pour votre réponse.

J'avais déjà tomber sur votre exemple sur stackoverflow :

a = mp.Process(target = test.median)
b = mp.Process(target = test.mean)
a.start()
b.start()

Mais sa ne fonctionne pas, il n'y a pas de calcule sur plusieurs core.
J'ai un I5 4 core, quand je lance le programme, le cpu monte à 25% (au lieu de 50) et il n'y a qu'un process python qui tourne.
@sazearte s'agit t'il des limitations du langage que vous parliez plus haut ?

**wiztricks** · 02/08/2016, 11h16

Envoyé par lulu7

J'ai un I5 4 core, quand je lance le programme, le cpu monte à 25% (au lieu de 50) et il n'y a qu'un process python qui tourne.

Ca c'est parce que "par défaut" scipy et numpy pensent que vérouillent les processus sur un même CPU permet de profiter des données en "cache" (du CPU).
Donc il faut changer ce qu'on appelle l'affinity des différents process via la primitive ad hoc de votre OS ou la fonction os.sched_setaffinity (dispo en 3.5).

note: si vous voulez calculer vite, il faut connaître pas mal de chose sur la mémoire, les processeurs, OS, les langages,...

- W

**lulu7** · 02/08/2016, 11h47

note: si vous voulez calculer vite, il faut connaître pas mal de chose sur la mémoire, les processeurs, OS, les langages,...

Ce que je cherche c'est exécuter une méthode d'un objet dans un processus A
En parallèle lancer un Processus B qui exécute une autre méthode du même objet

l'exemple que j'ai donné c'était pour exprimer mon problème, à savoir que même avec votre solution proposé je suis bridé à un core physique.
En java quand je lance 2 threads ils s’exécute sur 2 core différents, ici avec le multi-processing normalement je devrais avoir 2 process sur 2 core, mais ce n'est pas le cas, j'ai un processus python qui tourne.

**wiztricks** · 02/08/2016, 12h59

Envoyé par lulu7

En java quand je lance 2 threads ils s’exécute sur 2 core différents, ici avec le multi-processing normalement je devrais avoir 2 process sur 2 core, mais ce n'est pas le cas, j'ai un processus python qui tourne.

Si vous ne jouez pas avec l'affinity, c'est normal (et ce n'est pas python" mais "numpy" (qui n'est pas écrit en python).

Pour le reste Python est un langage de scripting, ce qui n'est pas sans conséquences.
Mais cela a peut d'importance car on ne code pas avec Python, Perl ou Ruby (qui ont aussi un GIL) les mêmes applications qu'avec des langages compilés comme Java, C, C++.

- W

**RyzenOC** · 02/08/2016, 13h43

le problème n'est pas du à numpy, j'ai repris ton exemple mais sans numpy :

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
 
import multiprocessing as mp
import random
import ctypes 
 
class DataManager:
	def __init__(self):
		self.data = [int(1000*random.random()) for i in range(5000000)]
 
	def mean(self):
		self.t1=sum(self.data)/len(self.data)
		print(self.t1)
 
	def mean2(self):
		self.t2=sum(self.data)**2/len(self.data)
		print(self.t2)
 
if __name__ == '__main__':
	test=DataManager()
 
	a = mp.Process(target = test.mean2)
	b = mp.Process(target = test.mean)
	a.start() 
	b.start()

Sa ne tourne que sur 1 seul cœur de processeur.

J'ai bien compris votre probleme lulu7, j'ai regardé du coté de affinity (ce que préconise @wiztricks), que se soit avec ou sans numpy j'ai rien trouvé de concluant sur le net, ou alors c'est des vieux post de 10ans sous python 2.7

**wiztricks** · 02/08/2016, 14h55

Envoyé par sazearte

le problème n'est pas du à numpy, j'ai repris ton exemple mais sans numpy :

Sa ne tourne que sur 1 seul cœur de processeur.

J'ai bien compris votre probleme lulu7, j'ai regardé du coté de affinity (ce que préconise @wiztricks), que se soit avec ou sans numpy j'ai rien trouvé de concluant sur le net, ou alors c'est des vieux post de 10ans sous python 2.7

Ici la difficulté est de partager un outil de mesure qui permette à tout un chacun de montrer ce qu'il voit.
Donc j'instrumente le code avec psutil histoire de voir le pourcentage utilisé de chaque core et je bourre un peu la bête avec des boucles plutôt qu'en augmentant la taille des données: çà tourne le temps que je veux sans flinguer les pagefiles.

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
27
28
29
30
31
32
33
34
35
36
37
38
39
import multiprocessing as mp
import psutil
import time
import numpy as np
import ctypes
 
class DataManager:
    def __init__(self, N=100):
        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):
        while True:
            ar = self.data.mean(axis=0)
 
    def median(self):
        while True:
            ar = self.data.std()
 
 
if __name__ == '__main__':
    P = []
 
    dm = DataManager()
 
    P.append(mp.Process(target=dm.mean))
    P.append(mp.Process(target=dm.median))
 
    psutil.cpu_percent(percpu=True)
    print('before', psutil.cpu_percent(interval=0.5, percpu=True))
 
    [ p.start() for p in P ]
    for x in range(10):
            print(psutil.cpu_percent(interval=0.5, percpu=True))
    [ p.terminate() for p in P ]
    time.sleep(0.1)
    print('after', psutil.cpu_percent(interval=0.5, percpu=True))

Et en sortie j'obtiens:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
before [0.0, 0.0, 0.0]
[65.6, 67.7, 65.6]
[68.8, 80.6, 48.4]
[75.0, 65.6, 58.1]
[71.9, 59.4, 67.7]
[78.8, 78.1, 43.8]
[90.6, 58.1, 50.0]
[65.6, 71.9, 66.7]
[71.9, 80.6, 50.0]
[75.0, 56.2, 68.8]
[71.9, 56.2, 71.9]
after [0.0, 0.0, 0.0]

Le boulot(*) est bien distribué sur tous les CPU présents.
(*) et je conviens que c'est sa seule utilité.

Ce qui me conforte à penser que vous ne regardez pas l'utilisation de vos CPU/core avec les bons outils ou que "affinity" a été forcé par "numpy" ou autre.

- W

**lulu7** · 02/08/2016, 18h27

merci, ici effectivement mes core sont tous actifs.

je suis en train de regarder pour les partages en mémoires de mes objets et matrices 2d.

**RyzenOC** · 02/08/2016, 19h01

tu ne pourra pas, en python tu ne peut pas partager en mémoire des objets, pas de manière automatique.
Tu peut bidouiller en utilisant pickle ou manager.

Pour ma part, j'ai développer un programme qui permet de tous partager de manière "universelle", à l'exeption de certaines lib comme les ihm sous tkinter ou qt par exemple (tous ce que pickle peut pas en faite), voici mon code avec 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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
import multiprocessing as m
import pickle
 
#code "universelle"
class Store:
    pass
 
class Shareable:
    def __init__(self, size = 2**10):
        object.__setattr__(self, 'store', m.Array('B', size))
        o = Store() # This object will hold all shared values
        s = pickle.dumps(o)
        store(object.__getattribute__(self, 'store'), s)
 
    def __getattr__(self, name):
        s = load(object.__getattribute__(self, 'store'))
        o = pickle.loads(s)
        return getattr(o, name)
 
    def __setattr__(self, name, value):
        s = load(object.__getattribute__(self, 'store'))
        o = pickle.loads(s)
        setattr(o, name, value)
        s = pickle.dumps(o)
        store(object.__getattribute__(self, 'store'), s)
 
def store(arr, s):
    for i, ch in enumerate(s):
        arr[i] = ch
 
def load(arr):
    l = arr[:]
    return bytes(arr)
 
 
#tes objects ou structure a partager, voici un exemple
 
class Foo(Shareable):
    def __init__(self):
        super().__init__()
        self.f = 1
        self.f2 = 1
        self.mylist=[0,1,2,3,4,5,6]
 
    def foo(self):
        self.f += 1
        """while True:
            self.f2+=1"""
 
def Otherprocess(s):
    print("Process2 :")
    print(s.f)
    s.mylist=[0]
    """while True:
        s.f2+=1"""
 
if __name__ == '__main__':
    import multiprocessing as m
    import time
    s = Foo()
    print(s.f)
    p = m.Process(target=s.foo, args=())
    p.start()
    #p.join()
    p2 = m.Process(target=Otherprocess, args=(s,))
    p2.start()
    time.sleep(1)
    print("Process1 :")
    print(s.f)
    print(s.mylist)