python多处理特有的内存管理

Question

我有一个简单的多处理代码：

from multiprocessing import Pool
import time 

def worker(data):
    time.sleep(20)

if __name__ == "__main__":
    numprocs = 10
    pool = Pool(numprocs)
    a = ['a' for i in xrange(1000000)]
    b = [a+[] for i in xrange(100)]

    data1 = [b+[] for i in range(numprocs)]
    data2 = [data1+[]] + ['1' for i in range(numprocs-1)]
    data3 = [['1'] for i in range(numprocs)]

    #data = data1
    #data = data2
    data = data3


    result = pool.map(worker,data)

b只是一个很大的清单。 data是传递给pool.map的长度numprocs的列表，因此我希望numprocs进程被派生，并且每个data元素都将传递给其中一个。 我测试了3个不同的data对象： data1和data2实际上具有相同的大小，但是当使用data1 ，每个进程都获取同一对象的副本，而当使用data2 ，一个进程获取所有data1的副本，而其他进程仅获取一个“ 1” （基本上没有）。 data3基本上是空的，无法衡量派生过程的基本开销成本。

问题： data1和data2之间使用的总内存差异很大。 我测量了最后一行（pool.map（））使用的额外内存量，然后得到：

1. data1 ：〜8GB
2. data2 ：〜0.8GB
3. data3 ：〜0GB

1）和2）不应相等，因为传递给子级的数据总量是相同的。 到底是怎么回事？

我从Linux机器上的/ proc / meminfo的Active字段测量内存使用情况（总计MemFree给出相同的答案）

Answer 1

您所看到的是pool.map副作用，该方法必须腌制data中的每个元素才能将其传递给子进程。

事实证明，腌制时data1比data2大得多。 这是一个小脚本，可将每个列表中每个元素的总腌制大小相加：

import pickle
import sys
from collections import OrderedDict

numprocs = 10
a = ['a' for i in range(1000000)]
b = [a+[] for i in range(100)]

data1 = [b+[] for i in range(numprocs)]
data2 = [data1+[]] + ['1' for i in range(numprocs-1)]
data3 = [['1'] for i in range(numprocs)]
sizes = OrderedDict()
for idx, data in enumerate((data1, data2, data3)):
    sizes['data{}'.format(idx+1)] = sum(sys.getsizeof(pickle.dumps(d))
                                            for d in data)

for k, v in sizes.items():
    print("{}: {}".format(k, v))

输出：

data1: 2002003470
data2: 200202593
data3: 480

如您所见， data1的总腌制大小约为data2的大小的十倍，这与两者之间的内存使用量的数量级差异完全匹配。

data2泡菜之所以小很多的原因是Cilyan在评论中提到的； 创建每个data列表时，实际上是在制作浅表副本：

>>> data2[0][2][0] is data2[0][0][0]
True
>>> data2[0][2][0] is data2[0][3][0]
True
>>> data2[0][2][0] is data2[0][4][0]
True

现在， data1正在制作浅表副本：

>>> data1[0][0] is data1[1][0]
True
>>> data1[0][0] is data1[2][0]
True

关键区别在于，使用data2 ，所有浅表副本都位于可迭代（ data2[0] ）的一个顶级元素内。 因此，当pool.map对该元素进行腌制时，它可以将所有浅表副本重复数据删除到一个子列表中，然后对该一个子列表以及相应的元数据进行腌制，描述了该子列表如何嵌套到data2 。 随着data1 ，浅拷贝是跨越不同的顶级元素data1 ，所以pool.map单独咸菜他们，这意味着重复数据删除丢失。 因此，当您释放data1 ，浅表副本已消失，每个元素都有一个唯一但相等的子列表副本。

比较这两个示例，其中data1和data2与您的列表相同：

>>> before_pickle1 = data1[0]
>>> before_pickle2 = data1[1]
>>> before_pickle1 is before_pickle2
False
>>> before_pickle1[0] is before_pickle2[0]
True  # The lists are the same before pickling
>>> after_pickle1 = pickle.loads(pickle.dumps(before_pickle1))
>>> after_pickle2 = pickle.loads(pickle.dumps(before_pickle2))
>>> after_pickle1[0] is after_pickle2[0]
False  # After pickling, the lists are not the same
>>> before_pickle1 = data2[0]

>>> before_pickle1[0][0] is before_pickle1[1][0]
True
>>> after_pickle1 = pickle.loads(pickle.dumps(before_pickle1))
>>> after_pickle1[0][0] is after_pickle1[1][0]
True # The lists are still the same after pickling

这模拟了相同的酸洗pool.map 。 使用data1 ，由于浅拷贝而造成的所有重复数据删除都将丢失，这将使内存使用率大大提高。