Comment partager efficacement des données volumineuses en lecture seule dans le multitraitement Python ?

Maintenir les données partagées en lecture seule dans le multitraitement

Question :

Dans un environnement multitraitement Python, comment garantir qu'un tableau en lecture seule de grande taille (par exemple, 3 Go) est partagé entre plusieurs processus sans créer de copies ?

Réponse :

Utiliser les capacités de mémoire partagée fournies par le Le module multitraitement associé à NumPy permet un partage efficace des données entre les processus.

<code class="python">import multiprocessing
import ctypes
import numpy as np

shared_array_base = multiprocessing.Array(ctypes.c_double, 10*10)
shared_array = np.ctypeslib.as_array(shared_array_base.get_obj())
shared_array = shared_array.reshape(10, 10)</code>

Cette approche exploite le fait que Linux utilise la sémantique de copie sur écriture pour fork(), garantissant que les données ne sont dupliquées que lorsque modifié. Par conséquent, même sans utiliser explicitement le multiprocessing.Array, les données sont effectivement partagées entre les processus à moins qu'elles ne soient modifiées.

<code class="python"># Parallel processing
def my_func(i, def_param=shared_array):
    shared_array[i,:] = i

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    pool.map(my_func, range(10))

    print(shared_array)</code>

Ce code modifie simultanément le tableau partagé et démontre le partage réussi des données entre plusieurs processus :

[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 2.  2.  2.  2.  2.  2.  2.  2.  2.  2.]
 [ 3.  3.  3.  3.  3.  3.  3.  3.  3.  3.]
 [ 4.  4.  4.  4.  4.  4.  4.  4.  4.  4.]
 [ 5.  5.  5.  5.  5.  5.  5.  5.  5.  5.]
 [ 6.  6.  6.  6.  6.  6.  6.  6.  6.  6.]
 [ 7.  7.  7.  7.  7.  7.  7.  7.  7.  7.]
 [ 8.  8.  8.  8.  8.  8.  8.  8.  8.  8.]
 [ 9.  9.  9.  9.  9.  9.  9.  9.  9.  9.]]

En tirant parti de la mémoire partagée et de la sémantique de copie sur écriture, cette approche fournit une solution efficace pour partager de grandes quantités de données en lecture seule entre les processus dans un environnement multitraitement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!