Wie kann man große schreibgeschützte Daten in Python-Multiprocessing effizient teilen?

Verwaltung gemeinsam genutzter schreibgeschützter Daten im Multiprocessing

Frage:

In einer Python-Multiprocessing-Umgebung Wie kann sichergestellt werden, dass ein großes schreibgeschütztes Array (z. B. 3 GB) von mehreren Prozessen gemeinsam genutzt wird, ohne Kopien zu erstellen?

Antwort:

Nutzung der von der bereitgestellten Shared-Memory-Funktionen Das Multiprocessing-Modul ermöglicht in Verbindung mit NumPy einen effizienten Datenaustausch zwischen Prozessen.

<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>

Dieser Ansatz nutzt die Tatsache, dass Linux die Copy-on-Write-Semantik für fork() verwendet, um sicherzustellen, dass Daten nur dann dupliziert werden, wenn modifiziert. Dadurch werden die Daten auch ohne explizite Verwendung des multiprocessing.Array effektiv zwischen Prozessen gemeinsam genutzt, sofern sie nicht geändert werden.

<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>

Dieser Code ändert gleichzeitig das gemeinsam genutzte Array und demonstriert die erfolgreiche gemeinsame Nutzung von Daten zwischen mehreren Prozessen:

[[ 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.]]

Durch die Nutzung von Shared Memory und Copy-on-Write-Semantik bietet dieser Ansatz eine effiziente Lösung für die gemeinsame Nutzung großer Mengen schreibgeschützter Daten zwischen Prozessen in einer Multiprozessorumgebung.

Das obige ist der detaillierte Inhalt vonWie kann man große schreibgeschützte Daten in Python-Multiprocessing effizient teilen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!