python - multiprocessing.pool 上下文和负载平衡

Question

我遇到了 python 多处理 Pool 类的一些意外行为。

这是我的问题:
1) Pool什么时候创建它的上下文，稍后用于序列化？
只要 Pool 对象是在 Container 定义之后创建的，下面的示例就可以正常运行。如果交换池初始化，则会发生序列化错误。在我的生产代码中，我想在定义容器类之前初始化 Pool 方式。是否可以刷新池“上下文”或以其他方式实现此目的。
2)Pool是否有自己的负载均衡机制，如果有，它是如何工作的？
如果我在带有 8 个进程池的 i7 机器上运行类似的示例，我会得到以下结果:
- 对于轻量级评估函数 Pool 倾向于仅使用一个进程进行计算。它根据请求创建 8 个进程，但大多数时候只使用一个进程(我从内部打印了 pid，也在 htop 中看到了这一点)。
- 对于重评估函数，行为符合预期。它平等地使用所有 8 个进程。
3) 使用 Pool 时，我总是看到我请求的另外 4 个进程(即，对于 Pool(processes=2)，我看到 6 个新进程)。他们的作用是什么？

我使用 Linux 和 Python 2.7.2

from multiprocessing import Pool
from datetime import datetime

POWER = 10

def eval_power(container):
    for power in xrange(2, POWER):
        container.val **= power
    return container

#processes = Pool(processes=2)

class Container(object):
    def __init__(self, value):
        self.val = value

processes = Pool(processes=2)

if __name__ == "__main__":
    cont = [Container(foo) for foo in xrange(20)]
    then = datetime.now()
    processes.map(eval_power, cont)
    now = datetime.now()
    print "Eval time:", now - then

编辑 - 前往巴库留
1) 我担心情况就是这样。
2)我不明白linux调度程序与python将计算分配给进程有什么关系。我的情况可以用下面的例子来说明:

from multiprocessing import Pool
from os import getpid
from collections import Counter


def light_func(ind):
    return getpid()


def heavy_func(ind):
    for foo in xrange(1000000):
        ind += foo
    return getpid()


if __name__ == "__main__":
    list_ = range(100)
    pool = Pool(4)
    l_func = pool.map(light_func, list_)
    h_func = pool.map(heavy_func, list_)

    print "light func:", Counter(l_func)
    print "heavy func:", Counter(h_func)

在我的 i5 机器(4 线程)上，我得到以下结果:
灯光函数:计数器({2967: 100})
重载函数:Counter({2969: 28, 2967: 28, 2968: 23, 2970: 21})
看来情况正如我所描述的那样。但是我还是不明白为什么python会这样做。我的猜测是，它试图最大限度地减少通信费用，但它用于负载平衡的机制仍然未知。该文档也不是很有帮助，多处理模块的文档非常少。
3) 如果我运行上面的代码，我会得到 4 个以上的进程，如前所述。屏幕来自htop:/image/PldmM.png

Answer 1

1. Pool对象在调用 __init__ 期间创建子进程因此您必须定义Container前。顺便说一句，我不会将所有代码包含在单个文件中，而是使用模块来实现 Container和其他实用程序，并编写一个启动主程序的小文件。

2. Pool完全按照 documentation 中的描述进行操作。特别是它无法控制进程的调度，因此您所看到的就是 Linux 调度程序认为它是正确的。对于小型计算，它们花费的时间很少，以至于调度程序不会费心并行化它们(由于核心亲和性等，这可能具有更好的性能)

3. 您能否通过示例以及您在任务管理器中看到的内容来展示这一点？我认为它们可能是处理Pool内的队列的进程。 ，但我不确定。在我的机器上，我只能看到主进程和两个子进程。

<小时/>

第 2 点更新:

Pool对象只是将任务放入队列中，子进程从该队列中获取参数。如果一个进程几乎不需要时间来执行一个对象，那么 Linux 调度程序会让该进程执行更多时间(从而消耗队列中的更多项目)。如果执行需要很长时间，那么该调度程序将更改进程，从而其他子进程也会被执行。

在您的情况下，单个进程正在消耗所有项目，因为计算所需的时间非常短，以至于在其他子进程准备好之前它已经完成了所有项目。

正如我所说，Pool没有做任何关于平衡子流程的工作的事情。它只是一个队列和一群工作人员，池将项目放入队列中，进程获取项目并计算结果。据我所知，它控制队列的唯一方法是将一定数量的任务放入队列中的单个项目中(请参阅 the documentation )，但不能保证哪个进程将获取哪个任务。其他一切都留给操作系统。

在我的机器上，结果没那么极端。对于轻型计算，两个进程的调用次数大约是其他两个进程的两倍，而对于重型计算，所有进程都或多或少地处理相同数量的项目。也许在不同的操作系统和/或硬件上我们会得到不同的结果。