如何限制多处理过程的范围？

Question

使用python的multiprocessing模块，以下设计的示例以最小的内存要求运行：

import multiprocessing 
# completely_unrelated_array = range(2**25)

def foo(x):
    for x in xrange(2**28):pass
    print x**2

P = multiprocessing.Pool()

for x in range(8):
    multiprocessing.Process(target=foo, args=(x,)).start()

取消对创建completely_unrelated_array ，你会发现每一个衍生的进程分配内存的副本completely_unrelated_array ！ 这是一个更大的项目的最小例子，我无法弄清楚如何解决方法; 多处理似乎可以复制全局的所有内容。 我并不需要一个共享内存对象，我只需要在通过x ，并处理它无需将整个程序的内存开销。

侧面观察 ：有趣的是foo中的print id(completely_unrelated_array)给出了相同的值，暗示某些可能不是副本...

Answer 1

由于性质的os.fork()在您的全局命名空间的变量__main__模块将由子进程继承（假设你是一个POSIX平台上），所以你会看到孩子们的内存使用情况一旦它们被创建就反映出来。 我不确定是否所有内存都是真正分配的，据我所知，内存是共享的，直到你真正尝试在子代中更改内存，此时会创建一个新副本。 另一方面，Windows不使用os.fork() - 它会重新导入每个子os.fork()的主模块，并os.fork()要发送给子os.fork()任何局部变量。 因此，使用Windows，您实际上可以通过仅在if __name__ == "__main__": guard中定义它来避免在子项中复制的大型全局结尾，因为该保护内部的所有内容都只会在父进程中运行：

import time
import multiprocessing 


def foo(x):
    for x in range(2**28):pass
    print(x**2)

if __name__ == "__main__":
    completely_unrelated_array = list(range(2**25)) # This will only be defined in the parent on Windows
    P = multiprocessing.Pool()

    for x in range(8):
        multiprocessing.Process(target=foo, args=(x,)).start()

现在，在Python 2.x中，如果您使用的是Posix平台，则只能通过分叉来创建新的multiprocessing.Process对象。 但是在Python 3.4上，您可以使用上下文指定如何创建新进程。 因此，我们可以指定"spawn"上下文，这是Windows使用的上下文，用于创建新进程，并使用相同的技巧：

# Note that this is Python 3.4+ only
import time
import multiprocessing 

def foo(x):
    for x in range(2**28):pass
    print(x**2)


if __name__ == "__main__":
    completely_unrelated_array = list(range(2**23))  # Again, this only exists in the parent
    ctx = multiprocessing.get_context("spawn") # Use process spawning instead of fork
    P = ctx.Pool()

    for x in range(8):
        ctx.Process(target=foo, args=(x,)).start()

如果您需要2.x支持，或者希望坚持使用os.fork()来创建新的Process对象，我认为您可以做的最好的方法是将报告的内存使用率降低，立即删除子Process的违规对象：

import time
import multiprocessing 
import gc

def foo(x):
    init()
    for x in range(2**28):pass
    print(x**2)

def init():
    global completely_unrelated_array
    completely_unrelated_array = None
    del completely_unrelated_array
    gc.collect()

if __name__ == "__main__":
    completely_unrelated_array = list(range(2**23))
    P = multiprocessing.Pool(initializer=init)

    for x in range(8):
        multiprocessing.Process(target=foo, args=(x,)).start()
    time.sleep(100)

Answer 2

这里重要的是您要定位的平台。 Unix系统进程是使用Copy-On-Write（cow）内存创建的。 因此，即使每个进程都获得父进程的完整内存的副本，该内存实际上仅在修改时按页面基数（4KiB）分配。 因此，如果您只是针对这些平台，则无需进行任何更改。

如果您的目标是没有牛叉的平台，您可能需要使用python 3.4及其新的分叉上下文spawn和forkserver ，请参阅文档这些方法将创建与父进程无共享或有限状态的新进程，并且所有内存传递都是显式的。

但并不是因为生成的进程将导入您的模块，因此将显式复制所有全局数据，并且不可能进行写入时复制。 为了防止这种情况，您必须减少数据范围。

import multiprocessing  as mp
import numpy as np

def foo(x):
    import time
    time.sleep(60)

if __name__ == "__main__":
    mp.set_start_method('spawn')
    # not global so forks will not have this allocated due to the spawn method
    # if the method would be fork the children would still have this memory allocated
    # but it could be copy-on-write
    completely_unrelated_array = np.ones((5000, 10000))
    P = mp.Pool()
    for x in range(3):
        mp.Process(target=foo, args=(x,)).start()

例如，spawn的最高输出：

%MEM     TIME+ COMMAND
29.2   0:00.52 python3                                                
0.5   0:00.00 python3    
0.5   0:00.00 python3    
0.5   0:00.00 python3    

和叉子：

%MEM     TIME+ COMMAND
29.2   0:00.52 python3                                                
29.1   0:00.00 python3    
29.1   0:00.00 python3                                                
29.1   0:00.00 python3

请注意，由于写入时复制，它超过100％