所以，我正在尝试使用 multiprocessing.Pool 和 Numpy，但似乎我错过了一些重要的点。为什么 pool 版本要慢得多？我查看了 htop，我可以看到创建了多个进程，但它们都共享一个 CPU，加起来约为 100%。

$ cat test_multi.py 
import numpy as np
from timeit import timeit
from multiprocessing import Pool


def mmul(matrix):
    for i in range(100):
        matrix = matrix * matrix
    return matrix

if __name__ == '__main__':
    matrices = []
    for i in range(4):
        matrices.append(np.random.random_integers(100, size=(1000, 1000)))

    pool = Pool(8)
    print timeit(lambda: map(mmul, matrices), number=20)
    print timeit(lambda: pool.map(mmul, matrices), number=20)

$ python test_multi.py 
16.0265390873
19.097837925

[更新]

• 更改为用于基准测试过程的 timeit
• 用我的一些核心初始化池
• 更改了计算，以便有更多的计算和更少的内存传输(我希望如此)

仍然没有变化。 pool 版本仍然较慢，我可以在 htop 中看到只使用了一个核心，还产生了几个进程。

[更新2]

目前我正在阅读@Jan-Philip Gehrcke 关于使用multiprocessing.Process() 和Queue 的建议。但与此同时我想知道:

1. 为什么我的例子对蒂亚戈有效？它无法在我的机器上运行的原因可能是什么 1 ？
2. 在我的示例代码中，进程之间是否存在任何复制？我打算用我的代码为每个线程提供矩阵列表中的一个矩阵。
3. 我的代码是一个不好的例子吗，因为我使用了 Numpy？

我了解到，当其他人知道我的最终目标时，通常有人会得到更好的答案:我有很多文件，这些文件以串行方式加载和处理。处理是 CPU 密集型的，所以我认为并行化可以获得很多。我的目标是调用并行分析文件的 python 函数。此外，我认为这个函数只是 C 代码的接口(interface)，这会有所不同。

1 Ubuntu 12.04、Python 2.7.3、i7 860 @ 2.80 - 如果您需要更多信息，请发表评论。

[update3]

以下是 Stefano 示例代码的结果。由于某种原因，没有加速。 :/

testing with 16 matrices
base  4.27
   1  5.07
   2  4.76
   4  4.71
   8  4.78
  16  4.79
testing with 32 matrices
base  8.82
   1 10.39
   2 10.58
   4 10.73
   8  9.46
  16  9.54
testing with 64 matrices
base 17.38
   1 19.34
   2 19.62
   4 19.59
   8 19.39
  16 19.34

[更新 4] 对 Jan-Philip Gehrcke's comment 的回答

抱歉，我没有说清楚。正如我在 Update 2 中所写，我的主要目标是并行化第 3 方 Python 库函数的许多串行调用。这个函数是一些 C 代码的接口(interface)。我被推荐使用 Pool，但这没有用，所以我尝试了一些更简单的方法，如上面显示的 numpy 示例。但也在那里我无法实现性能改进，即使它看起来对我来说是“embassing parallelizable”。所以我想我一定错过了一些重要的事情。这些信息正是我通过这个问题和赏金寻找的。

[更新 5]

感谢您的大力投入。但是通读你的答案只会给我带来更多问题。出于这个原因，我将阅读有关 basics 的内容并在我对我不知道的内容有更清晰的了解时创建新的 SO 问题。

最佳答案

关于所有进程都在同一个 CPU 上运行的事实，see my answer here .

在导入期间，numpy 会更改父进程的 CPU 亲和性，这样当您稍后使用 Pool 时，它产生的所有工作进程最终都会争夺对于同一个内核，而不是使用您机器上可用的所有内核。

您可以在导入 numpy 后调用 taskset 来重置 CPU 亲和性，以便使用所有内核:

import numpy as np
import os
from timeit import timeit
from multiprocessing import Pool


def mmul(matrix):
    for i in range(100):
        matrix = matrix * matrix
    return matrix

if __name__ == '__main__':

    matrices = []
    for i in range(4):
        matrices.append(np.random.random_integers(100, size=(1000, 1000)))

    print timeit(lambda: map(mmul, matrices), number=20)

    # after importing numpy, reset the CPU affinity of the parent process so
    # that it will use all cores
    os.system("taskset -p 0xff %d" % os.getpid())

    pool = Pool(8)
    print timeit(lambda: pool.map(mmul, matrices), number=20)

输出:

    $ python tmp.py                                     
    12.4765810966
    pid 29150's current affinity mask: 1
    pid 29150's new affinity mask: ff
    13.4136221409

如果您在运行此脚本时使用 top 观察 CPU 使用情况，您应该会看到它在执行“并行”部分时使用了所有内核。正如其他人所指出的那样，在您的原始示例中，酸洗数据、流程创建等所涉及的开销可能超过了并行化可能带来的任何好处。

编辑:我怀疑单个进程似乎始终更快的部分原因是 numpy 可能有一些技巧来加速元素矩阵当作业分布在多个核心时它无法使用的乘法。

例如，如果我只使用普通的 Python 列表来计算斐波那契数列，我可以通过并行化获得巨大的加速。同样，如果我以不利用矢量化的方式进行逐元素乘法，我将获得与并行版本类似的加速:

import numpy as np
import os
from timeit import timeit
from multiprocessing import Pool

def fib(dummy):
    n = [1,1]
    for ii in xrange(100000):
        n.append(n[-1]+n[-2])

def silly_mult(matrix):
    for row in matrix:
        for val in row:
            val * val

if __name__ == '__main__':

    dt = timeit(lambda: map(fib, xrange(10)), number=10)
    print "Fibonacci, non-parallel: %.3f" %dt

    matrices = [np.random.randn(1000,1000) for ii in xrange(10)]
    dt = timeit(lambda: map(silly_mult, matrices), number=10)
    print "Silly matrix multiplication, non-parallel: %.3f" %dt

    # after importing numpy, reset the CPU affinity of the parent process so
    # that it will use all CPUS
    os.system("taskset -p 0xff %d" % os.getpid())

    pool = Pool(8)

    dt = timeit(lambda: pool.map(fib,xrange(10)), number=10)
    print "Fibonacci, parallel: %.3f" %dt

    dt = timeit(lambda: pool.map(silly_mult, matrices), number=10)
    print "Silly matrix multiplication, parallel: %.3f" %dt

输出:

$ python tmp.py
Fibonacci, non-parallel: 32.449
Silly matrix multiplication, non-parallel: 40.084
pid 29528's current affinity mask: 1
pid 29528's new affinity mask: ff
Fibonacci, parallel: 9.462
Silly matrix multiplication, parallel: 12.163

关于python - Multiprocessing.Pool 使 Numpy 矩阵乘法变慢，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15414027/