Discussion :

[RyzenOC]

J'ai un objet qui crée une fenêtre tkinter, depuis cette fenêtre je peut instancier (avec un bouton) un objet qui récupéré des données en provenance de fichiers et génère 2 listes.

Une fois ces 2 grosses listes crée, je crée un 3eme objet, dans un autre processus, qui lance une fenêtre tkinter avec un graphe matploltib dedans. Le graphique matplotlib affiche mes 2 listes

Pourquoi s'embêter avec le multi-processing ?, pour pouvoir avoir des graphiques lancée dans des processus différents, car matploltib n'exploite qu'un core, c'est pour pas bridé mon programme à 25% de mon cpu (j'ai 4 core)

[wiztricks]

Salut,

Une fois ces 2 grosses listes crée, je crée un 3eme objet, dans un autre processus, qui lance une fenêtre tkinter avec un graphe matploltib dedans. Le graphique matplotlib affiche mes 2 listes

grosse listes d'objets Python <=> pickle et transferts de messages entre les processus qui sera très inefficace et lent.
Il faudrait essayer de mapper (via mmap) ça directement en mémoire et utiliser des données simples (int, long, double) "mappables" par numpy et pas mal de boulot pour faire tomber çà en marche.

- W

[RyzenOC]

Pour mes 2 listes, j'en ai une qui contient des doubles/float, et une autre des dates.
Je sais pas si on peut mapper des dates ?

Je vais voir pour mmap, c'est peut être la solution.

[wiztricks]

Pour mes 2 listes, j'en ai une qui contient des doubles/float, et une autre des dates.
Je sais pas si on peut mapper des dates ?

Un datetime, c'est un quadword (64 bits sur les systèmes modernes) donc "on peut".
Ceci dit, c'est compliqué et plein de pièges. Vous avez des tas de discussions sur ce sujet sur le ouèbe. çà serait bien d'y jeter un oeil pour apprécier la complexité de la chose.

- W

[RyzenOC]

Ceci dit, c'est compliqué et plein de pièges. Vous avez des tas de discussions sur ce sujet sur le ouèbe. çà serait bien d'y jeter un oeil pour apprécier la complexité de la chose.

Oui j'ai vue, je vais déjà essayé de faire une version "basique", avec juste ma liste de double.

[RyzenOC]

j'ai réussie a partager ma matrice de float:

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
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
from time import sleep
from random import randint
 
import test
 
 
def heavy_duty_function(mytab):
	c = 0
	while c < 10**2:
		c += 1
	print(test.shared_array_base[0])
 
 
def _initialize_subprocess(shared_array_base):
	"Initialise notre subprocess avec la mémoire partagée."
	test.shared_array_base = shared_array_base
 
def from_array_to_np(array):
	"Transforme multiprocessing.Array -> np.array"
	shared_array = np.frombuffer(array.get_obj())
	return shared_array.reshape(4, 4)
 
def list_of_list_to_array(data):
	return np.array(data)
 
if __name__=='__main__':
 
	mylist=[[0.0,1.5,2,3,4,5,6], [0,1,2,3,4,5,6]]
 
	shared_array_base = list_of_list_to_array(mylist)
	with Pool(processes=None, initializer=_initialize_subprocess, initargs=(shared_array_base,)) as pool:
		pool.map(heavy_duty_function, range(1))

Pour les dates j'ai pas encore trouvé, mais je pense qu'il suffira d'utiliser le type datetime à la place de c_float et sa marcheras.


Mais mon but n'est pas de lancer une fonction, mais de crée un bojet, peut on instancier un objet avec pool ?
voici mon code (qui ne marche pas)

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
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
from time import sleep
from random import randint
 
import numpy as np
import test
 
class memory2():
	def __init__(self, arg1, arg2):
 
		self.ar1=arg1
		self.arg2=arg2
		c = 0
		while c < 10**2:
			c += 1
		print(test.shared_array_base[0])
 
 
def _initialize_subprocess(shared_array_base):
	"Initialise notre subprocess avec la mémoire partagée."
	test.shared_array_base = shared_array_base
 
def list_of_list_to_array(data):
	return np.array(data)
 
if __name__=='__main__':
 
	mylist=[[0.0,1.5,2,3,4,5,6], [0,1,2,3,4,5,6]]
	#mylist = [[randint(0, 30000000) for i in range(30000)] for j in range(300)]
	shared_array_base = list_of_list_to_array(mylist)
 
	with Pool(processes=None, initializer=_initialize_subprocess, initargs=(shared_array_base,)) as pool:
		pool.map(memory2, range(1))

[wiztricks]

Salut,

Mais mon but n'est pas de lancer une fonction, mais de crée un bojet, peut on instancier un objet avec pool ?

Un bout de mémoire partagée entre processus créé via multiprocessing.Array pourra difficilement être assigné à autre chose qu'une variable globale et créée dans la portion "if __name__ == '__main__':".
Rien ne vous empêche ensuite de regrouper un paquet de fonctions dans un emballage de type "class" qui auront des attributs en mémoire séparée et qui pourront accéder aux cases de l'Array partagé. Mais c'est un vrai boulot à construire et à mettre au point.

- W

[RyzenOC]

c'est bon j'ai réussie:

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
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
 
import test
 
class Memory:
    def __init__(self, arg1, arg2):
        self.arg1 = arg1
        self.arg2 = arg2
 
    def do_something_useful(self):
        c = 0
        while c < 10**7:
            c += 1
        print(test.shared_array_base[self.arg1 + self.arg2])
 
def just_do_it(arg1, arg2):
    memory = Memory(arg1, arg2)
    memory.do_something_useful()
 
def _initialize_subprocess(shared_array_base):
    test.shared_array_base = shared_array_base
 
def list_of_list_to_array(data_type, data):
    return Array(data_type, [elt for row in data for elt in row], lock=False)
 
if __name__ == '__main__':
    mylist = [[i+j*5000 for i in range(5000)] for j in range(5000)]
    shared_array_base = list_of_list_to_array(ctypes.c_int, mylist)
 
    with Pool(processes=None,
              initializer=_initialize_subprocess,
              initargs=(shared_array_base,)) as pool:
        pool.starmap(just_do_it, [(5, 10)])

Ma matrice de 1Gb est enfin partager, je sens que mon programme vas énormément y gagner en perf, car mon pc n'a que 4GB de ram et quand sa dépasse l'os swap et le pc lag à mort, voir est carrément inutilisable.

[YCL-1]

Je voulais crée un processus après un clique sur une fenêtre tkinter, mais ce nouveau processus, je voulais pouvoir le manipuler depuis le processus parent :

voici le code que j'avais développé:

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
 
# -*- coding: utf-8 -*-
 
from tkinter import *
import multiprocessing
 
 
class NewProcess():
	def __init__(self):
		self.name="mon processus"
 
	def mamethode(self):
		print("hello")
 
 
def CreateNewProcess():
	proc=NewProcess()
	proc.mamethode()
	return proc
 
class Window():
 
    def __init__(self):
        self.fenetre = Tk()
        self.fenetre.geometry("700x880+100+0")
        self.fenetre.minsize(840, 70)
 
 
        def startprocess():
            proc = multiprocessing.Process(target=CreateNewProcess, args=())
            proc.start()	
	   #proc.mamethode()
 
        button = Button(self.fenetre, text="run", command=lambda: startprocess())
        button.pack()
 
        self.fenetre.mainloop()
 
if __name__ == '__main__':
    Window=Window()

Seulement j'ai 2 problème:
Je ne peut pas manipuler mon objet NewProcess depuis l'objet Window
Si je transforme mon code en exécutable avec cx_freeze, quand je clique sur run, ça me crée une nouvelle fenêtre tkinter, ça ne m'affiche pas "hello"

Bonsoir,

si quelqu'un a une explication à ce sujet ça m'intéresse aussi.
J'ai essayé de mon côté avec Python 3.4.4 win x86 et cx_Freeze 4.3.4

Est-ce une limitation / interprétation différente de cx_Freeze lors de la compilation.

Window() s'instancie à chaque fois qu'on clique sur "run" : startprocess()

Très curieux.


J'ai déjà fait l'expérience d'un comportement différent quand le code est compilé sur l'attribut __file__ qui n'existe pas ou retourne None. Ce qui n'est pas pratique pour aller chercher un icône dans un chemin relatif à l'exécutable.

La solution trouvée sur stackoverflow : http://stackoverflow.com/a/404750

Code :

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

1
2
3
4
5
6
7
8
import os
import sys
 
# determine if application is a script file or frozen exe
if getattr(sys, 'frozen', False):
    application_path = os.path.dirname(sys.executable)
elif __file__:
    application_path = os.path.dirname(__file__)

Il y a fort à parier que l'explication se trouve dans une subtilité de ce genre.

[RyzenOC]

si quelqu'un a une explication à ce sujet ça m'intéresse aussi.
J'ai essayé de mon côté avec Python 3.4.4 win x86 et cx_Freeze 4.3.4

Est-ce une limitation / interprétation différente de cx_Freeze lors de la compilation.

Window() s'instancie à chaque fois qu'on clique sur "run" : startprocess()

Très curieux.


J'ai déjà fait l'expérience d'un comportement différent quand le code est compilé sur l'attribut __file__ qui n'existe pas ou retourne None. Ce qui n'est pas pratique pour aller chercher un icône dans un chemin relatif à l'exécutable.

En faite c'est tous simple, il suffit juste de rajouter juste après le if __name__ == '__main__':

Code :

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

1
2
3
 
if __name__ == '__main__':
   multiprocessing.freeze_support()

Cette solution fonctionne chez moi. freeze_support() n'est utile que sur les OS windows, sous linux y'a pas ce genre de problème d'après ce que j'ai compris.

Il parait même que sous linux, une variable global peut même être partager entre plusieurs processus, pas besoin de s'embêter avec tous mon code.
j'ai pas testé, donc à ne pas prendre pour argent comptant.

Enfin sa fait 2 semaines maintenant que je me mets au multi-processing, mais je pense aujourd'hui avoir surmonté toutes les subtilités, entre les comportement étrange de tkinter, le freeze_support(), et la mémoire partagés, je crois avoir fais le tour des problèmes.

En tous cas j'espère que mes bouts de codent vous aiderons.
Dernière chose aussi, si vous voulez utiliser cx_freeze avec python3.5, ne perdez pas votre temps, c'est pas encore compatible. Il vous faudra télécharger le dernier repository et compiler vous même les sources. Vous devrez pour cela télécharger et installer Visual Studio 2015, (les outils de C++ suffirons), ce qui à pris 3H chez moi...

Vous l'aurez compris, pour faire marcher la bestiole, faut pas mal bidouiller.

[YCL-1]

Merci pour votre retour très utile,
je n'ai jamais eu pour l'instant à utiliser le multiprocessing mais je sais que ça va me servir pour plus tard !

En tous cas j'espère que mes bouts de codent vous aiderons.
Dernière chose aussi, si vous voulez utiliser cx_freeze avec python3.5, ne perdez pas votre temps, c'est pas encore compatible. Il vous faudra télécharger le dernier répertoire et compiler vous même les sources. Vous devrez pour cela télécharger et installer Visual Studio 2015, (les outils de C++ suffirons), ce qui à pris 3H chez moi...

Vous l'aurez compris, pour faire marcher la bestiole, faut pas mal bidouiller.

C'est souvent ça avec les librairies tierces, NumPy et consorts, il vaut mieux rester à la version Python mineure - 1.

Sinon il existe le site « Unofficial Windows Binaries for Python Extension Packages » qui distribue les librairies compilées pour les dernières versions de Python : http://www.lfd.uci.edu/~gohlke/pythonlibs/
C'est très pratique, surtout sur un poste bureautique (quand on n'a pas toujours le choix), un simple dézip et copie dans site-packages et ça roule. (à défaut d'avoir pip bien entendu)
ou presque : http://stackoverflow.com/a/35706103

Enfin ça fait 2 semaines maintenant que je me mets au multi-processing, mais je pense aujourd'hui avoir surmonté toutes les subtilités, entre les comportement étrange de tkinter, le freeze_support(), et la mémoire partagés, je crois avoir fais le tour des problèmes.

Au sujet de tkinter il y a une chose à savoir avant de démarrer un projet avec, c'est qu'il n'est pas thread-safe, et la solution de contournement - autre que de passer par la librairie tierce mtTkinter - est d'utiliser des queue pour remonter toutes les actions sur le __main__, ça devient beaucoup plus lourd : http://effbot.org/zone/tkinter-threads.htm (exemple python v2)

[RyzenOC]

je rencontre actuellement un autre problème, avec les arrays, j'arrive a partager ma liste de liste, mais je n'arrive a retrouver sa taille:

Quand je fais appelle a mon array partager, j'obtient un tableau 1D.

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
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from multiprocessing import Pool, Array
from functools import partial
import ctypes
import numpy as np
from time import sleep
 
import test
 
 
def heavy_duty_function(line):
    "La fonction qu'on parallélise"
    # On garde le CPU stupidement occupé...
    # On peut vérifier le nombre de coeur qui travaillent.
    c = 0
    while c < 10**7:
        c += 1
    shared_array = from_array_to_np(test.shared_array_base)
    print(shared_array[line])
 
def _initialize_subprocess(shared_array_base):
    test.shared_array_base = shared_array_base
 
def list_of_list_to_array(data_type, data):
    return Array(data_type, [elt for row in data for elt in row], lock=False)
 
def from_array_to_np(array):
    shared_array = np.frombuffer(array, dtype=float)
    return shared_array
 
 
if __name__=='__main__':
    data = [[0,1,2,3],[4,5,6],[4,5,6,7,9]]
    shared_array_base = list_of_list_to_array(ctypes.c_double, data)
 
    with Pool(processes=4, initializer=_initialize_subprocess, initargs=(shared_array_base,)) as pool:
        pool.map(heavy_duty_function, range(2))
 
    shared_array = from_array_to_np(shared_array_base)

[wiztricks]

Salut,

je rencontre actuellement un autre problème, avec les arrays, j'arrive a partager ma liste de liste, mais je n'arrive a retrouver sa taille:

len(array)?

- W

[RyzenOC]

Code :

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

len(array)?

Non, t'a pas compris, je convertit une liste 2d en array:

Code :

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

maliste=[[0,1,2,3,4,5][6,7,8]]

Mais mon array, lui n'a qu'une dimension:

Code :

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

1
2
print(myarray)
0,1,2,4,5,6,7,8

comment recrée un array 2D ?

[wiztricks]

comment recrée un array 2D ?

Côté mémoire partagée, ce ne sont que des tableaux 1D. Si vous voulez utiliser cela comme un tableau 2D il faut écrire le code qui calcule l'index dans le tableau 1D à partir de 2 entiers (i, j) et réciproquement.

- W