如何正确开始并行执行两个函数的多个参数?

Question

我正在寻找一种方法来并行启动两个函数，每个函数在给定的一组不同的参数上执行。我使用pool.map来实现这一目标。我创建了两个不同的进程，每个进程启动一个执行map的池。这是有效的-执行顺序有点乱，但我将把它留到另一个问题。

现在我也找到了另一种方法(参见第一个答案)。它们只使用一个池，并且连续两次调用map_async。所以我想知道，是否有更好的方法来做到这一点?因为我读到(很遗憾，我不记得在哪里)最好只使用一个池，这意味着第二种方法(只使用一个池)更好。但是当我测量时间时，第一种方法(在单独的进程中使用两个池)实际上要快一点。此外，在第一种方法中，函数实际上是并行运行的，而在第二种方法中，首先执行map_async的第一个调用，然后执行第二个调用。

下面是我的测试代码:

from multiprocessing import Process, Pool
import time
import os
multiple_pools = True
data = list(range(1, 11))

def func_a(param):
print(f'running func_a in process {os.getpid()}')
print(f'passed argument: {param}')
print('calculating...n')
time.sleep(1.5)
print('donen')
def func_b(param):
print(f'running func_b in process {os.getpid()}')
print(f'passed argument: {param}')
print('calculating...n')
time.sleep(2.5)
print('donen')
def execute_func(func, param):
p = Pool(processes=8)
with p:
p.map(func, param)

if __name__ == '__main__':
if not multiple_pools:
t0 = time.time()
p = Pool(processes=8)
res = p.map_async(func_a, data)
res = p.map_async(func_b, data)
p.close()
p.join()
t1 = time.time()
dt = t1 -t0
print(f'time spent with one pool: {dt} s')
else:
t0 = time.time()
p1 = Process(target=execute_func, args=(func_a, data))
p2 = Process(target=execute_func, args=(func_b, data))
p1.start()
p2.start()
p1.join()
p2.join()
p1.close()
p2.close()
t1=time.time()
dt = t1 -t0
print(f'time spent with two pools, each inside an own process: {dt} s')

所以，我的问题是:有一种方式比另一种方式更受欢迎吗?或者其他更好的方法?

Answer 1

首先，我假设当您使用两个池时，您将使用非阻塞map_async方法。我想说，两个大小为N的池，每个池向每个池提交M个任务，其中所有任务都是相同的(即，就CPU, I/O等而言，需要相同的资源)，在执行时间上应该或多或少与向大小为2 * N的单个池提交相同的2 * M个任务相同

下面的程序演示了这两种情况:

from multiprocessing import Pool
import time
QUARTER_SECOND_ITERATIONS = 5_000_000
def quarter_second(x):
sum = 0
for _ in range(QUARTER_SECOND_ITERATIONS):
sum += 1
return x * x
def callback(result):
global callback_count
print('Two pools result:', result)
callback_count += 1
if callback_count == 2:
# Both map-async calls have completed:
print('Two pools time:', time.time() - start_time)
# required for Windows:
if __name__ == '__main__':
data1 = range(10)
data2 = range(10, 20)
# Two pools:
pool1 = Pool(4)
pool2 = Pool(4)
callback_count = 0
start_time = time.time()
pool1.map_async(quarter_second, data1, callback=callback)
pool2.map_async(quarter_second, data2, callback=callback)
pool1.close()
pool1.join()
pool2.close()
pool2.join()
# One Pool:
data = range(20)
pool = Pool(8)
start_time = time.time()
result = pool.map(quarter_second, data)
print('One pool result:', result)
print('One pool time:', time.time() - start_time)
pool.close()
pool.join()

打印:

Two pools result: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Two pools result: [100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
Two pools time: 1.4994373321533203
One pool result: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
One pool time: 1.4596436023712158

我重复了几次，大多数但不是所有的情况下，一个池的情况稍微好一些。但我的桌面上运行着许多其他进程，这些进程会影响测试结果。我没有在总时间中包括创建处理池的实际时间。此外，根据池的大小和可迭代参数的大小，map函数可以计算一个稍微不同的chunksize值，以便在没有指定显式chunksize参数时使用，就像这里的情况一样。但这对性能的影响可以忽略不计。总的来说，在我的假设下，我真的看不到单池和双池方法之间有什么显著的性能差异。