Discussion :

[Pistolero_JB]

Bonjour a tous,

c'est mon premier post ici,

j'ai une bizarrerie sur python et je ne vois pas pourquoi et comment gerer ca. Quelques mots sur le contexte, je charges en memoire (dans une variable python) un fichier volumineux ~5Go (liste de donnee provenant d'une matrice de 28805x28805 elements). Bref, mon probleme est dans le chargement du fichier dans la variable, par exemple si j'execute ce code:

Code :

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

1
2
3
4
5
n    = 100000000
data = [0.0] * n
val  = 1.25e+02
for i in xrange(n):
    data[n] = val

quand j'alloue de la memoire pour la variable, j'utilise ~ 740 Mo, et lorsque la boucle tourne pour remplir la variable data la mémoire reste constante car allouer au debut. Maintenant si j'execute ceci:

Code :

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

1
2
3
4
5
6
7
from string import atof
 
n    = 100000000
data = [0.0] * n
val  = '1.25e+02'
for i in xrange(n):
    data[n] = atof(val)

la memoire utiliser au depart est de 740 Mo a l'allocation puis ne cesse d'augmenter pendant ma boucle pour atteindre les 3.9 Go. Je penses que le probleme est que atof me retourne un flottant different du flottant utilise en allocation... qu'elle est le probleme... comment convertir ma chaine de caractere en flottant 32 bit.

Une suggestion ?

Merci

[Matthieu Brucher]

Bizarre.

Déjà, le module string est déprécié. Tu as essayé avec :

Code :

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

1
2
3
4
5
n    = 100000000
data = [0.0] * n
val  = '1.25e+02'
for i in xrange(n):
    data[n] = float(val)

?

Et pour des données aussi importantes, tu devrais passer à Numpy

[Pistolero_JB]

Le probleme est identique avec float(), la solution numpy je l'utilise actuellement en attendant, car quand j'alloue une variable array de type float 32 bit, la memoire reste constante. Le probleme avec ma variable array, c'est que j'ai remarque un ralentissement sur le temp d'acces des donnees, et donc un ralentissement de l'algo... ralentissement constater mais non evaluer, pas encore.

Effectivement, c'est tres bizarre...

[Matthieu Brucher]

Louche. Essaie de chopper le nombre de références en cours (je ne sais plus quelle est la fonction dans sys, mais ça devrait donner une indication).

[yacinechaouche]

Rien de nouveau : soit le programme utilise moins de mémoire, mais est plus lent, soit il utilise plus de mémoire et il est plus rapide. C'est très difficile d'avoir les deux en même temps.

[Matthieu Brucher]

Les deux programmes travaillent sur des listes de même taille, et à chaque fois un seul élément est modifié. Ta remarque est donc complètement à côté du problème.

[yacinechaouche]

...la solution numpy je l'utilise actuellement en attendant, car quand j'alloue une variable array de type float 32 bit, la memoire reste constante. Le probleme avec ma variable array, c'est que j'ai remarque un ralentissement...

Oups pardon. Mais j'ai cru lire qu'avec numpy il n'y avait pas de problème de mémoire, vu que numpy utilise des tableaux C, mais des problèmes de lenteurs.

Les deux autres solutions utilisent des listes et non des tableaux. Dans un cas, des floats sont directement injectés et la mémoire reste constante, dans l'autre, des chaînes sont converties en float et là la mémoire augmente.

J'en conclu donc :

• utilisation de numpy => temps plus lent mais pas de prob de mémoire.
• utilisation de listes pythons => pas de prob de temps mais problèmes de mémoire à la conversion des float.

J'ai bon là ?

[Matthieu Brucher]

Non, c'est lors de l'utilisation de la fonction float() ou atof() qu'il y a une fuite mémoire. Peut-être.

[yacinechaouche]

C'est ce que j'entendais par conversion de float.

[Matthieu Brucher]

Ce n'est pas dépendant de Numpy, c'est juste la conversion.

[Pistolero_JB]

Bon, a ce que j'en ai compris, dans python il y a une liste libre d'objets pour stocker les flottants, notamment pour faire de la copie d'une variable a une autre. C'est une sorte de buffer a objet flottant. Le probleme c'est que cette liste est immortelle, car re-utilisee pour d'autre objet flottant. C'est pour cela qu'au moment de la conversion il se creer une liste parallele de flottant augmentant la memoire. Et meme apres en relachant la variable utilisee, la memoire ne revient pas comme avant, car une partie de cette liste est toujours vivante.

Voila, en gros, je ne suis pas sur d'avoir tout compris en details (je ne suis pas un computer science ), si vous voulez suivre le fil de l'histoire avec un collegue on a poster un bug report http://bugs.python.org/issue3063

Merci, A+

[yacinechaouche]

Tout dans python est objet, floats compris.
Selon ce que j'ai compris du lien que tu as donné :

Dans ton premier code, tu créer un seul objet flottant qui est le flottant 1.25e+02 que tu stock dans val.

Dans ta boucle for, data[i] reçoit donc une référence vers le même objet. D'où l'usage constant de la mémoire (aucun nouvel objet flottant créé)

Dans ton deuxième code par contre, tu crées un nouvel objet float à chaque fois que tu fais appel à atof() ou à float(), il y a donc un nouvel objet par itération. Comme pour chaque flottant il faut aussi allouer de la mémoire pour sauvegarder un pointeur vers son type et un compteur de références, l'utilisation de la mémoire est en constante augmentation. (j'ai réussi à mettre constante et augmentation dans la même phrase )

Le mystère qui reste à résoudre pour moi c'est pourquoi est-ce que tu montes à près de 4 Go ??

[kedare]

Tu peut jeter un coups d'oeil du coté de psyco aussi pour booster les performances

[Pistolero_JB]

Psyco c'est bien mais les performances sont au détriment d'une consommation mémoire plus élevée, ce que justement je cherche a eviter. Bon, j'ai fait autrement, j'ai ecrit une couche en C pour charger et acceder a ma variable. Au final voila les comparaisons de temps et de memoire, pour l'allocation, le chargement et une boucle de scrutation sur l'ensemble des donnes, en utilisant une variable python, un array de numpy et d'une structure venant de ma sous couche en C. Tout cela pour des donnees brut de 12 497 500 flottants 32 bits:

Code :

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

1
2
3
4
5
 
                     Mem [Mo]        temps [s]                 
variable python      458 Mo          18.4
array NumPy          74 Mo           24.2
variable couche C    74 Mo           17.9

Ma solution me conviens, de toute maniere pour la rapidites je vais paralleliser l'algo et faire tourner ca sur plusieurs procs.

++

[Matthieu Brucher]

C'est louche tout de même. C'est quoi le code que tu utilises pour Numpy ?

[Pistolero_JB]

Exactement je sais plus trop, je n'ai pas le code sous les yeux, de memoire ca devais etre un truc dans ce genre :

Code :

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

1
2
 
data = array([0.0 for i in xrange(100000000)], 'f')

Je suis pas un grand specialiste de Numpy donc je sais pas trop quelle ecriture adopter pour que ce soit optimisee.

[Matthieu Brucher]

Code :

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

data = numpy.arange(10000, dtype=numpy.float)