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