Почему я должен проходить функцию с помощью инициализатора, когда она в любом случае глобальна? ⇐ Python

[Anonymous]

Возьмите это MWE: < /p>

Код: Выделить всё

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

def make_func():
n = 10000
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)

Я объявил f глобальным. Я думаю, что это означает, что в каждом работнике будет сделана копия большого массива Numpy.

Код: Выделить всё

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

def make_func():
n = 10000
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>
Мне сказали, что это лучший стиль, но я не вижу, что такое преимущество.  Я не уверен, почему f 

должен быть объявлен глобальным в `init_worker. В любом случае каждому работнику отправляется копия большого массива Numpy. В целом также кажется медленным.

Подробнее здесь: https://stackoverflow.com/questions/794 ... bal-anyway