Warum sollte ich eine Funktion mit Initializer übergeben und kann ich stattdessen gemeinsam genutztes Speicher verwenden ⇐ Python

[Guest]

Nehmen Sie diesen MWE: < /p>

Code: Select all

from multiprocessing import Pool
from time import perf_counter as now
import numpy as np

def make_func():
n = 20000
np.random.seed(7)
M = np.random.rand(n, n)
return lambda x, y: M[x, x] + M[y, y]

class ParallelProcessor:
def __init__(self):
pass

def process_task(self, args):
"""Unpack arguments internally"""
index, integer_arg = args
print(f(index, integer_arg))

def run_parallel(self, tasks, num_cores=None):
"""Simplified parallel execution without partial"""
num_cores = num_cores

task_args = [(idx, val) for idx, val in enumerate(tasks)]
start = now()
global f
f = make_func()
print(f"************** {now() - start} seconds to make f")
start = now()
with Pool(num_cores) as pool:
results = pool.map( self.process_task, task_args)
print(f"************** {now() - start} seconds to run all jobs")
return results

if __name__ == "__main__":
processor = ParallelProcessor()
processor.run_parallel(tasks=[1, 2, 3, 4, 5], num_cores=2)

Ich habe f global erklärt. Ich denke, das bedeutet, dass in jedem Arbeiter eine Kopie des großen Numpy -Arrays vorgenommen wird.

Code: Select all

from multiprocessing import Pool
from time import perf_counter as now
import time
import os
import numpy as np

def make_func():
n = 20000
np.random.seed(7)
M = np.random.rand(n, n)
return lambda x, y: M[x, x] + M[y, y]

def init_worker():
global f
f = make_func()

class ParallelProcessor:
def __init__(self):
pass

def process_task(self, args):
"""Unpack arguments internally"""
index, integer_arg = args
print(f(index, integer_arg))

def run_parallel(self, tasks, num_cores=None):
"""Parallel execution with proper initialization"""
num_cores = num_cores or len(os.sched_getaffinity(0))
task_args = [(idx, val) for idx, val in enumerate(tasks)]

start = now()
with Pool(num_cores, initializer=init_worker) as pool:
results = pool.map(self.process_task, task_args)
print(f"************** {now() - start} seconds to run all jobs")
return results

if __name__ == "__main__":
processor = ParallelProcessor()
processor.run_parallel(tasks=[1, 2, 3, 4, 5], num_cores=2)
< /code>
Mir wird gesagt, dass dies ein besserer Stil ist, aber ich kann nicht sehen, was der Vorteil ist.  Ich bin mir nicht sicher, warum F 

in `init_worker global erklärt werden muss. In jedem Fall wird immer noch eine Kopie des großen Numpy -Arrays an jeden Arbeiter gesendet. Insgesamt scheint es auch langsamer zu sein. < /P>
Ich verwende Linux. eine Kopie des Arrays bei jedem Arbeiter. Gibt es einen schnellen Weg, um den gemeinsam genutzten Speicher zu verwenden, um dies zu vermeiden?