使用multiprocessing.Manager.list而不是实际的list会使计算耗时较长

Question

我想尝试使用multiprocessing的不同方法，从以下示例开始：

$ cat multi_bad.py 
import multiprocessing as mp
from time import sleep
from random import randint

def f(l, t):
#   sleep(30)
    return sum(x < t for x in l)

if __name__ == '__main__':
    l = [randint(1, 1000) for _ in range(25000)]
    t = [randint(1, 1000) for _ in range(4)]
#   sleep(15)
    pool = mp.Pool(processes=4)
    result = pool.starmap_async(f, [(l, x) for x in t])
    print(result.get())

这里，l是一个列表，在生成4个进程时复制4次。为了避免这种情况，文档页面提供了使用队列、共享数组或使用multiprocessing.Manager创建的代理对象。最后一次，我更改了l的定义：

$ diff multi_bad.py multi_good.py 
10c10,11
<     l = [randint(1, 1000) for _ in range(25000)]
---
>     man = mp.Manager()
>     l = man.list([randint(1, 1000) for _ in range(25000)])

结果看起来仍然正确，但执行时间急剧增加，我认为我做错了：

$ time python multi_bad.py 
[17867, 11103, 2021, 17918]

real    0m0.247s
user    0m0.183s
sys 0m0.010s

$ time python multi_good.py 
[3609, 20277, 7799, 24262]

real    0m15.108s
user    0m28.092s
sys 0m6.320s

文档确实说，这种方式比共享数组慢，但这只是感觉不对。我也不知道我该如何描述这个来获得更多的信息。我遗漏了什么吗？

p.S.使用共享阵列，我得到的时间低于0.25秒

这是Linux和Python3.3上的。

Answer 1

当子进程是os.forked时，Linux使用copy-on-write来演示：

import multiprocessing as mp
import numpy as np
import logging
import os

logger = mp.log_to_stderr(logging.WARNING)

def free_memory():
    total = 0
    with open('/proc/meminfo', 'r') as f:
        for line in f:
            line = line.strip()
            if any(line.startswith(field) for field in ('MemFree', 'Buffers', 'Cached')):
                field, amount, unit = line.split()
                amount = int(amount)
                if unit != 'kB':
                    raise ValueError(
                        'Unknown unit {u!r} in /proc/meminfo'.format(u = unit))
                total += amount
    return total

def worker(i):
    x = data[i,:].sum()    # Exercise access to data
    logger.warn('Free memory: {m}'.format(m = free_memory()))

def main():
    procs = [mp.Process(target = worker, args = (i, )) for i in range(4)]
    for proc in procs:
        proc.start()
    for proc in procs:
        proc.join()

logger.warn('Initial free: {m}'.format(m = free_memory()))
N = 15000
data = np.ones((N,N))
logger.warn('After allocating data: {m}'.format(m = free_memory()))

if __name__ == '__main__':
    main()

它屈服了

[WARNING/MainProcess] Initial free: 2522340
[WARNING/MainProcess] After allocating data: 763248
[WARNING/Process-1] Free memory: 760852
[WARNING/Process-2] Free memory: 757652
[WARNING/Process-3] Free memory: 757264
[WARNING/Process-4] Free memory: 756760

这表明最初大约有2.5GB的空闲内存。 在分配15000x15000个float64s数组后，有763248 KB空闲空间。这大概是有道理的，因为15000**2*8字节=1.8GB，内存的减少，2.5GB-0.763248GB也大约是1.8GB。

现在，每个进程生成后，空闲内存再次报告为~750MB。可用内存没有明显减少，因此我得出结论，系统必须使用写时拷贝。

结论：如果不需要修改数据，那么在__main__模块的全局级别定义它是在子进程之间共享数据的一种方便且（至少在Linux上）内存友好的方式。