Python for 循环：多处理的正确实现

Question

以下 for 循环是迭代模拟过程的一部分，是计算时间的主要瓶颈：

import numpy as np

class Simulation(object):

    def __init__(self,n_int):
        self.n_int = n_int

    def loop(self):

        for itr in range(self.n_int):        
            #some preceeding code which updates rows_list and diff with every itr
            cols_red_list = []
            rows_list = list(range(2500)) #row idx for diff where negative element is known to appear
            diff = np.random.uniform(-1.323, 3.780, (2500, 300)) #np.random.uniform is just used as toy example 

            for row in rows_list:
                col =  next(idx for idx, val in enumerate(diff[row,:]) if val < 0)
                cols_red_list.append(col)
            # some subsequent code which uses the cols_red_list data    
sim1 = Simulation(n_int=10)
sim1.loop()

因此，我尝试通过使用multiprocessing包来并行化它，以期减少计算时间：

import numpy as np
from multiprocessing import  Pool, cpu_count
from functools import partial

def crossings(row, diff):
    return next(idx for idx, val in enumerate(diff[row,:]) if val < 0)

class Simulation(object): 
    def __init__(self,n_int):
        self.n_int = n_int

    def loop(self):        
        for itr in range(self.n_int): 
            #some preceeding code which updates rows_list and diff with every
            rows_list = list(range(2500))
            diff = np.random.uniform(-1, 1, (2500, 300))

            if __name__ == '__main__':
                num_of_workers = cpu_count()
                print('number of CPUs : ', num_of_workers)
                pool = Pool(num_of_workers)
                cols_red_list = pool.map(partial(crossings,diff = diff), rows_list)
                pool.close()
                print(len(cols_red_list))
            # some subsequent code which uses the cols_red_list data 

sim1 = Simulation(n_int=10)
sim1.loop()

不幸的是，与顺序代码相比，并行化要慢得多。 因此我的问题是：在那个特定的例子中我是否正确使用了 multiprocessing 包？ 是否有其他方法可以并行化上述 for 循环？

Answer 1

免责声明：当您试图通过并行化减少代码的运行时间时，这并不能严格回答您的问题，但它可能仍然是一个很好的学习机会。

作为黄金法则，在转向多处理以提高性能（执行时间）之前，应该首先优化单线程情况。

您的

rows_list = list(range(2500))

生成数字0到2499 （即range ）并将它们存储在内存中（ list ），这需要时间来分配所需的内存和实际写入。 然后，您只使用这些可预测值一次，方法是从内存中读取它们（这也需要时间），以可预测的顺序：

for row in rows_list:

当您重复执行时，这与loop函数的运行时特别相关（ for itr in range(n_int): ）。

相反，请考虑仅在需要时生成数字，而无需中间存储（这在概念上消除了访问 RAM 的任何需要）：

for row in range(2500):

其次，除了共享相同的问题（对内存的不必要访问）之外，还有以下内容：

diff = np.random.uniform(-1, 1, (2500, 300))
# ...
    col =  next(idx for idx, val in enumerate(diff[row,:]) if val < 0)

在我看来，在数学（或逻辑）层面上是可以优化的。

您要做的是通过将其定义为“我第一次在 [-1;1] 中遇到低于 0 的随机变量”来获得一个随机变量（即col索引）。 但是请注意，确定在 [-α;α] 上具有均匀分布的随机变量是否为负，与在 {0,1} 上（即bool ）具有随机变量相同。

因此，您现在使用的是bool s 而不是float s，您甚至不必进行比较（ val < 0 ），因为您已经有了 bool 。 这可能会使代码更快。 使用与rows_list相同的想法，您可以仅在需要时生成该bool ； 测试它直到它为True （或False ，选择一个，这显然无关紧要）。 通过这样做，你只生成你需要的随机bool s，不多也不少（顺便说一句，如果行中的所有 300 个元素都是负数，你的代码会发生什么？;））：

for _ in range(n_int):
    cols_red_list = []
    for row in range(2500):
        col = next(i for i in itertools.count() if random.getrandbits(1))
        cols_red_list.append(col)

或者，使用列表理解：

cols_red_list = [next(i for i in count() if getrandbits(1))
                 for _ in range(2500)]

我敢肯定，通过适当的统计分析，您甚至可以将col随机变量表示为 [0; 上的非均匀变量； limit [，让您可以更快地计算它。

请先测试您的单线程实现的“优化”版本的性能。 如果运行时仍然不可接受，那么您应该研究多线程。

Answer 2

multiprocessing使用系统进程（而不是线程！）进行并行化，这需要昂贵的 IPC（进程间通信）来共享数据。

这在两个方面咬你：

• diff = np.random.uniform(-1, 1, (2500, 300))创建一个大矩阵，这对于pickle/复制到另一个进程来说很昂贵
• rows_list = list(range(2500))创建一个较小的列表，但这里同样适用。

为了避免这种昂贵的 IPC，您有一个半选择：

• 如果在符合 POSIX 的系统上，请在模块级别初始化变量，这样每个进程都会获得所需数据的快速副本。 这是不可扩展的，因为它需要 POSIX、奇怪的架构（您可能不想将所有内容都放在模块级别），并且不支持共享对该数据的更改。
• 使用共享内存。 这仅支持大部分原始数据类型，但mp.Array应该可以满足您的需求。

第二个问题是设置池很昂贵，因为需要启动num_cpu进程。 与此开销相比，您的工作负载小到可以忽略不计。 一种好的做法是只创建一个池并重用它。

这是仅 POSIX 解决方案的一个简单粗暴的示例：

import numpy as np
from multiprocessing import  Pool, cpu_count
from functools import partial

n_int = 10

rows_list = np.array(range(2500))
diff = np.random.uniform(-1, 1, (2500, 300))


def crossings(row, diff):
    return next(idx for idx, val in enumerate(diff[row,:]) if val < 0)

def workload(_):
    cols_red_list = [crossings(row, diff) for row in rows_list]
    print(len(cols_red_list))


class Simulation(object):

    def loop(self):
        num_of_workers = cpu_count() 
        with Pool(num_of_workers) as pool:
            pool.map(workload, range(10))
        pool.close()

sim1 = Simulation()
sim1.loop()

对我（和我的两个核心）来说，这大约是顺序版本的两倍。

使用共享内存更新：

import numpy as np
from multiprocessing import  Pool, cpu_count, Array
from functools import partial

n_int = 10

ROW_COUNT = 2500


### WORKER

diff = None
result = None

def init_worker(*args):
    global diff, result
    (diff, result) = args


def crossings(i):
    result[i] = next(idx for idx, val in enumerate(diff[i*300:(i+1)*300]) if val < 0)


### MAIN

class Simulation():
    def loop(self):
        num_of_workers = cpu_count() 

        diff = Array('d', range(ROW_COUNT*300), lock=False)
        result = Array('i', ROW_COUNT, lock=False)
        # Shared memory needs to be passed when workers are spawned
        pool = Pool(num_of_workers, initializer=init_worker, initargs=(diff, result))

        for i in range(n_int):

            # SLOW, I assume you use a different source of values anyway.
            diff[:] = np.random.uniform(-1, 1, ROW_COUNT*300)

            pool.map(partial(crossings), range(ROW_COUNT))
            print(len(result))
        pool.close()


sim1 = Simulation()
sim1.loop()

一些注意事项：

• 共享内存需要在创建工作线程时设置，因此无论如何它都是全局的。
• 这仍然不比顺序版本快，但这主要是因为 random.uniform 需要完全复制到共享内存中。 我认为这只是用于测试的值，实际上您无论如何都会以不同的方式填充它。
• 我只将索引传递给工作人员，并使用它们来读取和写入共享内存的值。