Discussion :

[black-falco]

Bonjour!

En réalisant les opérations, Python ne semble pas libérer correctement la mémoire allouée:

Code :

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

1
2
3
4
 
ls = [ ['1.0'] * 3000 for i in range(20000)]
 
ls = [map(float, row) for row in ls]

ou

Code :

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

1
2
3
4
5
6
 
ls = [ ['1.0'] * 3000 for i in xrange(20000)]
 
for i in range(len(ls)):
 for j in range(len(ls[i])):
  ls[i][j] = float(ls[i][j])

Je ne comprends pas pourquoi l'espace mémoire alloué est largement supérieur à celui que possède la liste de liste de float.

Un del ne règle pas le problème, et gc.collect() n'a pas l'air d'arranger réellement les choses.

Idem pour la v2 du code avec une variable intermédiaire...

Quelqu'un a une idée de ce qui se passe vraiment pour que mes 2Go et mon swap aillent jusqu'à se remplir entièrement? (Testé sous Python 2.6.4 et 2.3)

[black-falco]

xrange...

[Zavonen]

Je confirme que sur mon système (python 2.6 sur ubuntu Lucid Lynx)
l'instruction del est inoéprante
par contre gc.collect() récupére sinon toute, au moins une bonne partie de la mémoire.

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
import subprocess
import gc
class MemoryMonitor(object):
 
    def __init__(self, username):
        """Create new MemoryMonitor instance."""
        self.username = username
 
    def usage(self):
        """Return int containing memory used by user's processes."""
        self.process = subprocess.Popen("ps -u %s -o rss | awk '{sum+=$1} END {print sum}'" % self.username,
                                        shell=True,
                                        stdout=subprocess.PIPE,
                                        )
        self.stdout_list = self.process.communicate()[0].split('\n')
        return int(self.stdout_list[0])
 
memory_mon = MemoryMonitor('gilles')
print memory_mon.usage()
ls = [ ['1.0'] * 3000 for i in range(20000)]
print memory_mon.usage()
ls = [map(float, row) for row in ls]
print memory_mon.usage()
del ls
print memory_mon.usage()
gc.collect()
print memory_mon.usage()
""" Résultat de l'exécution:
672436
1144088
3054936
3053980
1722168
"""

[PauseKawa]

Bonjour,

Heuuu... Je vais sans doute dire une bêtise mais cela me semble normal.

Python réserve un espace mémoire pour les variables suivant le type de variable et non la taille réelle de la variable en mémoire.
Un del ne fait qu'enlever le binding dans le namespace, pas l'allocation qui dépend du garbage.
Enfin... C'est ce que j'avais compris.

@+

[afranck64]

Bonsoir,

je crois qu'en Python la méthode pour libérer l'espace occupé par une variable c'est de lui affecter la valeur None

Code :

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

1
2
lst = range(1000000)
lst = None

@+ et bon code

[wiztricks]

del X ou X = None ne devraient avoir pour seul effet que de diminuer le nombre de références vers l'objet pointé par la variable X.

Ce qui permettra au prochain passage du garbage collector de libérer les objets dont le nombre de références est null.

gc.collect() force le passage du GC et la libération de la mémoire.

- W
PS: Lorsqu'on alloue/libère une liste de floats distincts, les résultats sont aussi surprenants.

[PauseKawa]

Bonsoir,

Je doute sur le lst = None. Pas le temps de tester mais cela n'est qu'une nouvelle affectation dans le namespace.

@+

Edit : Et mince, wiztricks a déjà répondu.