Remplir un dictionnaire en parallèle avec multitraitement

Question

Hier, j'ai posé une question: Reading data in parallel with multiprocess

Je suis très bonnes réponses, et j'implémenté la solution mentionnée dans la réponse que je marqué comme correct.

def read_energies(motif): 
    os.chdir("blabla/working_directory") 
    complx_ener = pd.DataFrame() 
    # complex function to fill that dataframe 
    lig_ener = pd.DataFrame() 
    # complex function to fill that dataframe 
    return motif, complx_ener, lig_ener 

COMPLEX_ENERGIS = {} 
LIGAND_ENERGIES = {} 
p = multiprocessing.Pool(processes=CPU) 
for x in p.imap_unordered(read_energies, peptide_kd.keys()): 
    COMPLEX_ENERGIS[x[0]] = x[1] 
    LIGAND_ENERGIES[x[0]] = x[2] 

Cependant, cette solution prend la même quantité de temps que si je voudrais juste itérer sur peptide_kd.keys() et remplir le DataFrames un par un. Pourquoi est-ce si? Y a-t-il un moyen de remplir les dicts désirés en parallèle et d'obtenir une augmentation de vitesse? Je l'utilise sur un HPC 48 core.

Answer 1

Vous encourez une bonne quantité de frais généraux dans (1) le démarrage de chaque processus, et (2) avoir à copier le pandas.DataFrame (et etc) à travers plusieurs processus. Si vous avez juste besoin d'avoir un dict rempli en parallèle, je suggère d'utiliser une mémoire partagée dict. Si aucune clé n'est écrasée, alors c'est facile et vous n'avez pas à vous soucier des verrous.

(Note J'utilise multiprocess ci-dessous, qui est une fourchette de multiprocessing - mais seulement je peux démontrer de l'interprète, sinon, vous auriez à faire le dessous de __main__).

>>> from multiprocess import Process, Manager 
>>> 
>>> def f(d, x): 
... d[x] = x**2 
... 
>>> manager = Manager() 
>>> d = manager.dict() 
>>> job = [Process(target=f, args=(d, i)) for i in range(5)] 
>>> _ = [p.start() for p in job] 
>>> _ = [p.join() for p in job] 
>>> print d 
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16} 

Cette solution ne permet pas de copies des dict à partager entre les processus, de sorte qu'une partie des frais généraux est réduite. Pour les objets de grande taille comme un pandas.DataFrame, il peut être significatif par rapport au coût d'une opération simple comme x**2. De même, engendrer un Process peut prendre du temps, et vous pouvez peut-être faire ce qui précède encore plus rapidement (pour les objets légers) en utilisant des threads (par exemple multiprocess.dummy au lieu de multiprocess pour votre solution originale ou la mienne ci-dessus).

Si vous faites besoin de partager DataFrames (comme votre code suggère plutôt comme la question demande), vous pourriez être en mesure de le faire en créant une mémoire partagée numpy.ndarray.