cPickle.load() en python consomme une grande mémoire

Question

J'ai un grand dictionnaire dont la structure ressemble à:

dcPaths = {'id_jola_001': CPath instance} 

où cpath est une classe d'auto-défini:

class CPath(object): 
    def __init__(self): 
     # some attributes 
     self.m_dAvgSpeed = 0.0 
     ... 
     # a list of CNode instance 
     self.m_lsNodes = [] 

où m_lsNodes est une liste des Nœuds-C:

class CNode(object): 
    def __init__(self): 
     # some attributes 
     self.m_nLoc = 0 

     # a list of Apps 
     self.m_lsApps = [] 

ici, m_lsApps est une liste de CApp, qui est une autre classe d'auto-défini:

class CApp(object): 
    def __init__(self): 
     # some attributes 
     self.m_nCount= 0 
     self.m_nUpPackets = 0 

Je sérialiser ce dictionnaire en utilisant cPickle:

def serialize2File(strFileName, strOutDir, obj): 
    if len(obj) != 0: 
     strOutFilePath = "%s%s" % (strOutDir, strFileName) 
     with open(strOutFilePath, 'w') as hOutFile: 
      cPickle.dump(obj, hOutFile, protocol=0) 
     return strOutFilePath 
    else: 
     print("Nothing to serialize!") 

Il fonctionne très bien et la taille du fichier sérialisé est d'environ 6.8GB. Cependant, lorsque je tente de désérialiser cet objet:

def deserializeFromFile(strFilePath): 
    obj = 0 
    with open(strFilePath) as hFile: 
     obj = cPickle.load(hFile) 
    return obj 

Je trouve qu'il consomme plus de mémoire 90GB et prend beaucoup de temps.

1. pourquoi cela se produirait-il?
2. Y a-t-il un moyen de l'optimiser?

BTW, j'utilise python 2.7.6

Answer 1

Vous pouvez essayer de spécifier le protocole de pickle; le plus rapide est -1 (ce qui signifie: le dernier protocole , pas de problème si vous décapez et défaites avec la même version Python).

cPickle.dump(obj, file, protocol = -1) 

EDIT: Comme indiqué dans les commentaires: load détecte le protocole lui-même.

cPickle.load(obj, file) 

Answer 2

Lorsque vous stockez des objets python complexes, python stocke habituellement beaucoup de données inutiles (voir la propriété d'objet __dict__). Afin de réduire la consommation de mémoire des données non sérialisées, vous ne devriez décaper que des python natifs. Vous pouvez y parvenir en implémentant facilement certaines méthodes sur vos classes: object.__getstate__() et object.__setstate__(state).

Voir sur la documentation python.