Discussion :

[RyzenOC]

Bonjour, je bute sur un problème assez gênant, python refuse de supprimé une variable qui prend de la place, voici mon code:

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
from tkinter import *
import multiprocessing
import os
 
def new_window(list):
    while True:
        print(list[0])
 
class Test:
    def __init__(self):
 
        def firstn(n):
            nums = []
            for i in range(0,n):   
                nums.append(i)
            return nums
 
        sum_of_first_n = firstn(2000000)
        self.new_window(sum_of_first_n)
        del sum_of_first_n
 
        print("end")
 
 
    def new_window(self, list):
        p = multiprocessing.Process(target=new_window, args=(list,))
        p.start()    
 
if __name__ == '__main__':
    toto = Test()

une fois p = multiprocessing.Process(target=new_window, args=(list,)) lancé, python vas copié ma variable list dans le nouveau processus, mais après ne vas pas supprimé (même manuellement avec del) cette derniere.

Du coup je me retrouve avec 90mo de ram au lieu de seulement 45, y'a t'il une solution ?

[tyrtamos]

Bonjour,

Essaie de lancer la méthode new_window comme ça:

Code :

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

self.new_window(sum_of_first_n[:])

[RyzenOC]

bonjour et merci pour ta réponse, mais malheureusement sa ne change rien.


Je maitrise mal l'outil multi-processing en python, plutot que de copier ma variable list dans le nouveau processus, serait t'il possible de la partager en mémoire directement ?, un peu comme le ferais une variable global ?

[VinsS]

Salut,

Tu sais que c'est une boucle sans fin çà:

Code :

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

1
2
3
4
 
def new_window(list):
    while True:
        print(list[0])

?

Ceci:

Code :

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

1
2
3
4
5
6
7
8
 
        def firstn(n):
            nums = []
            for i in range(0,n):   
                nums.append(i)
            return nums
 
        sum_of_first_n = firstn(2000000)

Revient à cela:

Code :

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

1
2
 
        sum_of_first_n = list(range(2000000)) # python 3

Pour ton problème, je pense que la liste créée est nums elle est ensuite retournée en référence et sum_of_first_n n'est qu'une deuxième étiquette de cette liste. C'est donc simplement cette deuxième référence que tu delete.

Aussi, évite d'utiliser un terme du langage, list par exemple, pour tes propres noms.

[RyzenOC]

Tu sais que c'est une boucle sans fin çà:

Oui, c'est pour que mon nouveau processus ne s’arrête pas

Pour ton problème, je pense que la liste créée est nums elle est ensuite retournée en référence et sum_of_first_n n'est qu'une deuxième étiquette de cette liste. C'est donc simplement cette deuxième référence que tu delete.

Aussi, évite d'utiliser un terme du langage, list par exemple, pour tes propres noms.

Pour le range, oui je sais que c'est équivalent, mais j'y ai pas pensé.

J'ai mis a jour mon code, mais aucun changement, je m'y attendais, car normalement python supprime toutes les variables une fois la fonction terminé.

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
from tkinter import *
import multiprocessing
import os
 
def new_window(list):
    while True:
        print(list[0])
 
class Test:
    def __init__(self):
 
        sum_of_first_n = list(range(2000000))
        self.new_window(sum_of_first_n)
        del sum_of_first_n
 
        print("end")
 
 
    def new_window(self, sum_of_first_n):
        p = multiprocessing.Process(target=new_window, args=(sum_of_first_n,))
        p.start()    
        del sum_of_first_n
 
if __name__ == '__main__':
    toto = Test()

[tyrtamos]

Je viens d'essayer le code du 1er message, et bizarrement, il fonctionne sans problème, c'est à dire que la tentative de supprimer la variable avec del s'exécute sans erreur.

Sinon, une solution simple pour partager une variable avec un processus est d'utiliser multiprocessing.Queue:
- On crée la queue dans le programme principal avec q=multiprocessing.Queue().
- On empile une donnée x dans la queue avec q.put(x), et on lit en dépilant la donnée avec y=q.get().
- On passe la queue q comme argument au lancement du processus

Voilà un petit code tout simple qui fait ça:

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3
 
import multiprocessing
 
#############################################################################
def calcul(q):
    """cette fonction est lancée dans un processus
       l'argument q est une pile contenant les arguments passés, et utilisé
       à la fin pour contenir le résultat
    """
    x = q.get()  # lecture et dépilage de l'argument empilé
    y = q.get()  # lecture et dépilage de l'argument empilé
    q.put(x * y)  # calcul et empilage du résultat
 
#############################################################################
if __name__ == '__main__':
 
    q = multiprocessing.Queue()
    q.put(3)  # on empile 3
    q.put(4)  # on empile 4
 
    proc = multiprocessing.Process(target=calcul, args=(q,))
    proc.daemon = True
    proc.start()
    proc.join()  # attendra la fin du processus
 
    print("resultat:", q.get())

Pour faire des choses plus compliquées, on peut utiliser multiprocessing.managers.

[wiztricks]

Salut,

une fois p = multiprocessing.Process(target=new_window, args=(list,)) lancé, python vas copié ma variable list dans le nouveau processus, mais après ne vas pas supprimé (même manuellement avec del) cette derniere.

Du coup je me retrouve avec 90mo de ram au lieu de seulement 45, y'a t'il une solution ?

Avez vous regardé ce qu'il se passe côté "mémoire" sans créer de process?
Normalement, après le "del", on a toujours 45 Mo occupés...

- W

[RyzenOC]

Voila ce que j'ai chez moi:


processus1 ave 95mo de ram, cpu a 0% (normal il fait plus rien)

processus2 95mo de ram, cpu 6% (a cause de ma boucle infinie)

[wiztricks]

Salut,

Voila ce que j'ai chez moi:

processus1 ave 95mo de ram, cpu a 0% (normal il fait plus rien)

processus2 95mo de ram, cpu 6% (a cause de ma boucle infinie)

Ce n'est pas ce que je vous ai demandé.
Vous faites une théorie comme quoi la mémoire devrait être libérée après un "del" et que si çà ne fonctionne pas çà serait à cause du multiprocessing. Moi je vous demande de vérifier ce qu'il se passe côté mémoire (après le "del") sans multiprocessing.
Vous devriez constater que la mémoire (ce que vous regardez) se comporte de la même façon.

- W

[RyzenOC]

Vous faites une théorie comme quoi la mémoire devrait être libérée après un "del" et que si çà ne fonctionne pas çà serait à cause du multiprocessing. Moi je vous demande de vérifier ce qu'il se passe côté mémoire (après le "del") sans multiprocessing.
Vous devriez constater que la mémoire (ce que vous regardez) se comporte de la même façon.

ok, je comprend, mais je fais comment moi pour supprimer cette variable ?

[wiztricks]

ok, je comprend, mais je fais comment moi pour supprimer cette variable ?

"del variable" fonctionne et si c'est la dernière référence à l'objet associé, le garbage collector fera le ménage. Python pourra allouer la mémoire libérée à d'autres objets (mais côté système, vous n'allez pas voir la mémoire se libérer: Python la garde pour lui).

- W

[RyzenOC]

Ah d'accord, merci pour ces explications.

Sinon est il possible de dire à python de libérer cette espace mémoire ?

[wiztricks]

Sinon est il possible de dire à python de libérer cette espace mémoire ?

Je ne pense pas que cela soit possible mais çà n'a pas grande importance. Normalement, le système va récupérer les pages inutilisées dès qu'il en aura besoin et çà ne coûtera que quelques IO disques.

- W

[VinsS]

Je ne pense pas que cela soit possible mais çà n'a pas grande importance. Normalement, le système va récupérer les pages inutilisées dès qu'il en aura besoin et çà ne coûtera que quelques IO disques.

- W

Il y a un temps j'avais enquêté sur le sujet pour une appli qui traite des images de grande taille et j'en étais arrivé à la même conclusion.

Au passage, je signale qu'il existe un moyen de connaître le nombre de références d'un objet:

Code :

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

1
2
3
4
5
6
 
>>> a = "jdhdg"
>>> import sys
>>> sys.getrefcount(a)
2
>>>

[wiztricks]

Salut,

Il y a un temps j'avais enquêté sur le sujet pour une appli qui traite des images de grande taille et j'en étais arrivé à la même conclusion.

Le gestionnaire de mémoire de Python est codé dans le module Objects/obmalloc.c. C'est relativement bien commenté. Python essaie de rendre de la mémoire depuis la version 2.5. Il ne peut pas le faire sans que de nombreuses conditions soient remplies et pour voir quelque chose, il faut qu'in fine, le système d'exploitation ne compte pas l'espace libéré comme étant toujours occupé.

- W

[RyzenOC]

pour en revenir a la mémoire j'ai adapté le code de tyrtamos, mais il y'a toujours le même problème, a savoir que la variable est copié dans la ram en double:

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
 
import multiprocessing
 
def calcul(q):
    print(q.get())
 
if __name__ == '__main__':
 
    q = multiprocessing.Queue()
    sum_of_first_n = list(range(2000000))
    q.put(sum_of_first_n)
 
    proc = multiprocessing.Process(target=calcul, args=(q,))
    proc.daemon = True
    proc.start()
    proc.join()  # attendra la fin du processus
 
    print("resultat:", q.get())

quand c'est 100-200mo sa vas, mais dans mon cas c'est une variable de 2Go, la copie je la sens passé. J'aimerais que python ne me copie pas en mémoire cette variable.

[tyrtamos]

Et en faisant directement:

Code :

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

    q.put(list(range(2000000)))

???

[wiztricks]

Salut,

quand c'est 100-200mo sa vas, mais dans mon cas c'est une variable de 2Go, la copie je la sens passé. J'aimerais que python ne me copie pas en mémoire cette variable.

Vu comme vous vous y prenez, çà ne va pas le faire.
Et comme je suppose que c'est pas juste pour le fun que vous essayez de partager une liste d'entiers entre processus, çà serait mieux d'expliquer ce que vous cherchez à faire et que vous donniez une idée de ce que sont les informations à partager et pourquoi vous voulez absolument utiliser multiprocessing dans ce cas.

- W

[RyzenOC]

Non c'est pas pour le fun en effet, a l'origine voila ce que je voulais faire:

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 executable avec cx_freeze, quand je clique sur run, sa me crée une nouvelle fenetre tkinter, sa ne m'affiche pas "hello"

[wiztricks]

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

ok, mais comment à partir de là vous vous retrouvez à recopiez des Mo d'un processus à l'autre? Qu'entendez vous par "manipuler"?

- W