[py 3.8] process start message bref ca marche jamais

**ikeas** · 25/01/2023, 11h11

Bonjour
j'ai fait un exemple auto porteur

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
72
73
74
75
76
77
78
79
80
81
82
83
import time
import multiprocessing
 
class SProcess(multiprocessing.Process): 
 
    def __init__(self):
        multiprocessing.Process.__init__(self)
        self._stopper = multiprocessing.Event()
 
    def stopit(self):
        self._stopper.set()
 
    def stopped(self):
        return self._stopper.is_set()
 
    def run(self):
        while True:
            if not self.stopped():
                time.sleep(1)    
            else: return
 
class Updater:
 
    def __init__(self):
        print("creation updater")
        self.__fluxs = []
 
    def __del__(self):
        print("destrution updater")
 
    def dispose(self):
        for f in self.__fluxs:
            f.stopit()
            f.join()
        self.__fluxs.clear()
 
    def __iadd__(self, flux):
        #flux.notifyFunc = self.changed
        self.__fluxs.append(flux)
        return self
 
    def startFluxs(self):
        for f in self.__fluxs:
            f.start()
 
    def changed(self):
         pass
 
class Flux(SProcess):
 
    def __init__(self):
        SProcess.__init__(self)
        self.notifyFunc = None
        print("creation flux")
 
    def __del__(self):
        print("destrution flux")
 
    @property
    def notifyFunc(self): return self._notifyFunc
 
    @notifyFunc.setter
    def notifyFunc(self, value): self._notifyFunc = value
 
 
def simmulation():
    print("creation")
    u = Updater()
    f1 = Flux()
    f2 = Flux()
    u += f1
    u += f2
    print("start all flux")
    u.startFluxs()
    print("pause")
    time.sleep(10)
    print("dispose updater")
    u.dispose()
 
if __name__ == "__main__":   
    print("-DEBUT---------------------------------------------------")
    simmulation()
    print("-END-----------------------------------------------------")

j'ai j'ai donc deux soucis :

Premier
si je decommente la ligne 38 (flux.notifyFunc = self.changed)
j'arrive plus a démarrer (cannot pickle 'weakref' object)

Le second
que je regarde la destruction
ben ca détruit deux fois les class flux comme si le passage avait ete dupliqué

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
-DEBUT---------------------------------------------------
creation
creation updater
creation flux
creation flux
start all flux
pause
dispose updater
destrution flux
destrution flux
destrution updater
destrution flux
destrution flux
-END-----------------------------------------------------

y'a quoi dans mon (magnifique) code qui coince ?
si vous avez une idée

**Sve@r** · 25/01/2023, 11h35

Bonjour

Envoyé par ikeas

j'ai fait un exemple auto porteur

Hum... je ne pige absolument pas le but de ce truc. Peut-être parce qu'il y a trop de commentaires...

Envoyé par ikeas

Le second
que je regarde la destruction
ben ca détruit deux fois les class flux comme si le passage avait ete dupliqué

alors déjà chez-moi (xubuntu64) le comportement n'est pas reproduit. Voici ce qui se passe à la fin...

Code :

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

1
2
3
4
5
6
pause
dispose updater
destrution flux
destrution flux
destrution updater
-END-----------------------------------------------------

... et donc pas de duplication comme mentionné.

Après on peut partir sur l'hypothèse de père mort avant le fils ou autres mais ça reste difficile à investiguer...

Envoyé par ikeas

Premier
si je decommente la ligne 38 (flux.notifyFunc = self.changed)
j'arrive plus a démarrer (cannot pickle 'weakref' object)

Déjà est-ce que tu veux appeler la méthode changed, ou simplement stocker sa référence? Parce que si tu veux l'appeler, il lui faut des parenthèses d'action => flux.notifyFunc = self.changed(). Et si tu veux juste stocker sa référence alors là encore en ce qui concerne le but de l'opération...

Sinon j'ai mis le premier point après le second car chez-moi là encore, avec ou sans commentaire, avec ou sans parenthèses d'action, le code fonctionne sans erreur (et sans duplication de __del__)

Sinon question Python pur, déjà on peut simplifier la méthode run()

Code python :

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

1
2
def run(self):
	while not self.stopped(): time.sleep(1)

Ensuite il ne faut pas oublier que la délégation s'applique à toutes les méthodes héritées, pas seulement le __init__(). Si comme je le pense la méthode (par exemple) run() est une surcharge de celle dont on hérite, il faut alors récupérer aussi l'originelle via super().run() quelque part.
Donc la méthode s'écrirait ainsi:

Code python :

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

1
2
3
def run(self):
	super().run()
	while not self.stopped(): time.sleep(1)

Et pareil pour toutes les autres méthodes éventuellement surchargées. La délégation ce n'est pas une option. Sinon on ne surcharge pas une méthode.

**ikeas** · 25/01/2023, 11h46

je vais t'expliquer le principe

j'ai un updater qui factorise les changement liés a plusieurs flux
donc il control les flux
le += de celui met en place pour le flux sa fonction de notification le changed

en gros quand un flux pourrait avoir un changement il ferrait self.notifyFunc() qui appellerait le changed puisqu'on a flux.notifyFunc = self.changed

sauf que évidement on a l'erreur de weakref

NOTA : j'ai modifié le code pour n'essayer qu'avec un seul flux et la ca marche comme si le partage de self.changed entre les deux process posait problème

pour le second problème je suis sur Windows avec python 3.8

**ikeas** · 25/01/2023, 12h07

je vais te refaire une maquette
sur le principe suivant

l'updateur est le maitre des flux
chaque flux connait son updateur dans le membre parent
et dans sa methode running (surcharge de celle de Sprocess)
il appel le parent.changed

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
import time
import weakref
import multiprocessing
 
class SProcess(multiprocessing.Process): 
 
    def __init__(self):
        multiprocessing.Process.__init__(self)
        self._stopper = multiprocessing.Event()
 
    def stopit(self):
        self._stopper.set()
 
    def stopped(self):
        return self._stopper.is_set()
 
    def run(self):
        while True:
            if not self.stopped():
                time.sleep(1) 
                self.running()
            else: return
 
    def running(self): pass
 
class Updater:
 
    def __init__(self):
        print("creation updater")
        self.__fluxs = []
 
    def __del__(self):
        print("destrution updater")
 
    def dispose(self):
        for f in self.__fluxs:
            f.stopit()
            f.join()
        self.__fluxs.clear()
 
    def __iadd__(self, flux):
        print(f"Ajoute flux {hash(flux)}")        
        self.__fluxs.append(flux)
        flux.parent = self
        return self
 
    def startFluxs(self):
        for f in self.__fluxs:
            print(f"start flux {hash(f)}")            
            f.start()
 
    def changed(self):
        print("CHANGED")
        pass
 
class Flux(SProcess):
 
    def __init__(self):
        SProcess.__init__(self)
        self.parent = None
        print(f"creation flux {hash(self)}") 
 
    def __del__(self):
        print(f"destrution flux {hash(self)}") 
 
    @property
    def parent(self): return self._parent
 
    @parent.setter
    def parent(self, value): 
        print("update notify func")
        self._parent = value
 
    def running(self):
        print(f"Set {hash(self)}")
        if not self.parent is None:
            self.parent.changed()
        else: 
            print("dropped")
 
 
def simmulation():
    print("creation")
    u = Updater()
    f1 = Flux()
    f2 = Flux()
    u += f1
    u += f2
    print("start all flux")
    u.startFluxs()
    print("pause")
    time.sleep(5)
    print("dispose updater")
    u.dispose()
 
if __name__ == "__main__":   
    print("-DEBUT---------------------------------------------------")
    simmulation()
    print("-END-----------------------------------------------------")

**Sve@r** · 25/01/2023, 12h20

Envoyé par ikeas

je vais t'expliquer le principe

j'ai un updater qui factorise les changement liés a plusieurs flux
donc il control les flux
le += de celui met en place pour le flux sa fonction de notification le changed

en gros quand un flux pourrait avoir un changement il ferrait self.notifyFunc() qui appellerait le changed puisqu'on a flux.notifyFunc = self.changed

sauf que évidement on a l'erreur de weakref

Ok. Je vois un peu mieux. Mais qqchose me chagrine inconsciemment sans que j'arrive à mettre le doigt dessus.
En fait l'addition reçoit un flux en paramètre, modifie ce flux pour y stocker le changed d'updater, puis ajoute ce flux dans son tableau interne. Quelque part je sens que c'est là un souci. Parce que que se passe-t-il si le updater reçoit un flux déjà terminé? C'est là que le weakref doit arriver.
De plus si j'ajoute plusieurs fois le même flux à l'updater, celui-ci stockera le même flux autant de fois que je l'ajoute. Je sens qu'il y a là un autre souci qui peut interférer. Il me semble que l'addition n fois ne devrait pas ajouter n fois le même flux. Donc ton updater doit connaitre les flux gérés pour checker les ajouts multiples.
Essaye de remplacer self.__fluxs = [] par self.__fluxs = set() et écrire ton __add__ ainsi

Code python :

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

1
2
3
4
5
6
7
def __add__(self, flux):
	if flux not in self.__fluxs:
		flux.notifyFunc = self.changed
		self.__fluxs.add(flux)
	# if
	return self
# __add__()

Il faudrait qu'il puisse aussi détecter un flux déjà terminé mais je ne vois pas comment faire...

Sinon tu remarqueras que j'ai remplacé __iadd__ par __add__. En effet, le __add__ prend en charge et l'addition et l'addition implicite, tandis que le __iadd__ ne prend en charge que l'addition implicite. Ainsi avec __add__ tu peux écrire au choix u+=f1 ou u=u+f1 ce qui correspond aux spécifications de l'opérateur "+" devant accepter les deux écritures.
Bref le __add__ est obligatoire si tu veux gérer l'addition et on ne met de __iadd__ que si son comportement doit différer du __add__.
Ensuite pour conserver la commutativité de l'addition, tu es obligé de définir un __radd__ qui te permet d'écrire u = f1+u. Il n'a pas besoin de tout reprendre puisqu'il peut parfaitement utiliser le __add__ déjà écrit comme def __radd__(self, flux): return self+flux mais il doit exister.
Cela peut aider.

Envoyé par ikeas

et dans sa methode running (surcharge de celle de Sprocess)

Si surcharge alors délégation obligatoire

Code python :

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

1
2
3
4
def running(self):
	super().running()
	pass		# Si tu veux montrer que la fonction n'est pas terminée...
# running()

Envoyé par ikeas

chaque flux connait son updateur dans le membre parent

Si l'updater est assuré d'exister à la création du flux, tu pourrais le lui passer au __init__ ce qui supprimerait ces __add__ qui me semblent inutiles (une addition qui ne peut se faire qu'une fois...). Ainsi le flux connaitrait le updater et toutes ses méthodes (y compris la méthode changed).
Exemple plus explicite

Code python :

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
72
73
74
75
76
77
78
79
import time
import multiprocessing
 
class SProcess(multiprocessing.Process): 
 
	def __init__(self):
		super().__init__()
		self._stopper = multiprocessing.Event()
 
	def stopit(self):
		self._stopper.set()
 
	def stopped(self):
		return self._stopper.is_set()
 
	def run(self):
		super().run()
		while not self.stopped(): time.sleep(1)	
 
class Updater:
	fluxs=property(lambda self: list(self.__fluxs))
 
	def __init__(self):
		print("creation updater", self)
		self.__fluxs = set()
 
	def __del__(self):
		print("destrution updater", self)
 
	def add(self, f): self.__fluxs.add(f)
	def remove(self, f): self.__fluxs.discard(f)
 
	def dispose(self):
		for f in self.__fluxs:
			f.stopit()
			f.join()
		self.__fluxs.clear()
 
	def startFluxs(self):
		for f in self.__fluxs: f.start()
 
	def changed(self):
		 pass
 
class Flux(SProcess):
 
	def __init__(self, updater):
		super().__init__()
		self.__updater=updater
		self.__updater.add(self)
		print("creation flux", self)
 
	def __del__(self):
		self.__updater.remove(self)
		print("destrution flux", self)
 
        @property
	def notifyFunc(self): return self._notifyFunc
 
        @notifyFunc.setter
	def notifyFunc(self, value): self._notifyFunc = value
 
 
def simmulation():
	print("creation")
	u = Updater()
	f1 = Flux(u)
	f2 = Flux(u)
	print("start all flux")
	u.startFluxs()
	print("pause")
	time.sleep(5)
	print("dispose updater")
	u.dispose()
 
if __name__ == "__main__":   
	print("-DEBUT---------------------------------------------------")
	simmulation()
	print("-END-----------------------------------------------------")

Chez-moi ça fonctionne...

Envoyé par ikeas

pour le second probleme je suis sur windows avec python 3.8

Hum... du multiprocess sous Windows...

**ikeas** · 25/01/2023, 12h44

en fait les flux sont pas démarrés déjà quand je fais les start
je crois que le problème viens du partage de référence sur le le parent
puisque chaque flux connait le même parent (un seul updateur)
et que manifestement le partage de ressource sur du multiprocessing en python c'est particulier

je sais pas si avec mon code initial avec le parent ca marche chez toi

j'ai repris ton code j'ai le meme soucis avec le weakref
tu es sous 3.8 ?

**Sve@r** · 25/01/2023, 14h37

Envoyé par ikeas

en fait les flux sont pas démarrés déjà quand je fais les start

Ca doit pouvoir se gérer avec is_alive() ou autre méthode de process...

Envoyé par ikeas

je crois que le problème viens du partage de référence sur le le parent
puisque chaque flux connait le même parent (un seul updateur)

Ca ne devrait pas poser de souci si, comme je le pense, l'updateur joue le rôle d'une espèce de tour de contrôle. On crée l'updateur puis on y associe les flux à leur création.

Envoyé par ikeas

et que manifestement le partage de ressource sur du multiprocessing en python c'est particulier

Pas en python, c'est sous Windows que c'est particulier. Python ne fait que s'appuyer sur son OS.

Envoyé par ikeas

je sais pas si avec mon code initial avec le parent ca marche chez toi

Sisi, le résultat que j'ai montré dans mon premier post c'était celui de ton code qui fonctione nickel sous Linux. Ensuite j'ai commencé à le charcuter.

Envoyé par ikeas

j'ai repris ton code j'ai le meme soucis avec le weakref
tu es sous 3.8 ?

3.10.
Mais je viens d'installer python 3.8 sur une VM Windows, et avec ton premier code, ou avec mon dernier, même problème.
Le souci vient de start() du flux lancé par le updater(). Il semble qu'en multiprocess Windows, le flux récupéré par le updater soit mal récupéré (il est récupéré en weakref=référence faible)
Si je rajoute une surcharge de start ainsi...

Code python :

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

1
2
3
def start(self):
	print("starting...", self)
	#super().start()

... tout marche nickel. Mais si je décommente le super().start() alors souci analogue au tien. Mais encore une fois seulement avec zindow. Lui en matière de multiprocess il se traine un sacré passif qui n'est pas prêt de s'arranger...

J'ai tenté de remplacer def add(self, f): self.__fluxs.add(f) par def add(self, f): self.__fluxs.add(copy.deepcopy(f)) (j'avais eu un souci une fois avec un connecteur MySQL que j'avais résolu via le module copy) mais ici que dalle.

Je suis en train d'examiner l'objet Process voir si on peut récupérer son coeur d'une façon ou d'une autre. Je vais essayer aussi avec pickle...

**wiztricks** · 25/01/2023, 13h58

Salut,

Envoyé par ikeas

pour le second problème je suis sur Windows avec python 3.8

Par défaut sur Linux, la création des autres processus se fait via fork alors qu'elle se fait par copie sous Windows. Qui dit copie, dit sérialisation d'objets via pickle (à renseigner si ça ne marche pas tout seul).

Pour le reste, soit vous écrit code comme on le sent et on peut constater que multiprocessing imposera ses règles derrière lesquelles on devra courir, soit on découvre les règles imposées par multiprocessing et on en tient compte pour écrire un code qui fera avec.

- W

**ikeas** · 25/01/2023, 14h23

et il n'y a pas de solutions simple pour partager des objets d'un processus a l'autre ?
j'ai reussi a faire un truc avec les manager

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
BaseManager.register('ParentClass', Updater)
	manager = BaseManager()
	manager.start()
	print("creation")	
	u = manager.ParentClass()
	f1 = Flux(u)
	f2 = Flux(u)
	print("start all flux")
	f1.start()
	f2.start()
	print("pause")
	time.sleep(5)
	print("dispose updater")
	f1.dispose()
	f2.dispose()

mais stocker les flux dans l'updateur j'ai une erreur
Pickling an AuthenticationString object is disallowed for security reasons
quand je veux le rajouter au tableau

**wiztricks** · 25/01/2023, 14h38

Envoyé par ikeas

et il n'y a pas de solutions simple pour partager des objets d'un processus a l'autre ?

Utiliser des threads à la place de process est une solution "simple" pour partager des objets.
Avec des processus séparés, on peut avoir de la mémoire commune (mais il y a du boulot pour en faire des objets).

Et quitte à me répéter, pour autant que la solution au problème que vous cherchez à résoudre passe par du multiprocessing, il va falloir apprendre à faire avec...

- W

[py 3.8] process start message bref ca marche jamais

Python

Vue hybride

Discussions similaires

Partager

Partager