python - 为什么joblib.Parallel()比非并行计算花费更多的时间？ Parallel()的运行速度是否应该比非并行计算快？

Question

joblib模块提供了一个简单的帮助程序类，以使用多处理并行编写循环的循环。

这段代码使用列表推导来完成这项工作：

import time
from math import sqrt
from joblib import Parallel, delayed

start_t = time.time()
list_comprehension = [sqrt(i ** 2) for i in range(1000000)]
print('list comprehension: {}s'.format(time.time() - start_t))

大约需要0.51s

list comprehension: 0.5140271186828613s

这段代码使用 joblib.Parallel()构造函数：

start_t = time.time()
list_from_parallel = Parallel(n_jobs=2)(delayed(sqrt)(i ** 2) for i in range(1000000))
print('Parallel: {}s'.format(time.time() - start_t))

大约需要31秒

Parallel: 31.3990638256073s

这是为什么？ Parallel()是否应该比无与伦比的计算更快？

这是 cpuinfo的一部分：

processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 79
model name      : Intel(R) Xeon(R) CPU @ 2.20GHz
stepping        : 0
microcode       : 0x1
cpu MHz         : 2200.000
cache size      : 56320 KB
physical id     : 0
siblings        : 8
core id         : 0
cpu cores       : 4
apicid          : 0
initial apicid  : 0
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes

Answer 1

问：Parallel()是否应该比无与伦比的计算更快？


好吧，这取决于很多情况（无论是joblib.Parallel()还是其他方式）。

没有任何免费的好处（自1917年以来，所有这些诺言都未能兑现。）

另外，很容易发生比您收到的回报（在启动多处理的生成过程中）要多的方式（期望在原始工作流程上加快速度）……因此必须格外小心



最好的第一步：

Revisit the Amdahl's law对流程计划效果的修订和批评（通过流程流程的重组并至少在某种程度上使用了并行的流程计划，实现了加速。）

最初的Amdahl公式并没有明确说明所谓的附加“成本”，人们必须为进入平行的工作流程而付出，而这些费用不在原始的纯[SERIAL]工作流程的预算之内。

1）在python中，过程实例化总是很昂贵，因为它首先必须复制尽可能多的副本（大小为n_jobs（2）-副本的O / S驱动的RAM分配+ O / S驱动的复制RAM映像主要python会话的周期）（基于线程的多处理会带来负面的提速，因为在所有产生的线程之间仍然存在对工作步骤的GIL锁重新[SERIAL]化，因此，尽管您付出了巨大的费用，产卵成本+每个附加GIL-ackquire / GIL-release舞步步骤-一种用于计算密集型任务的糟糕反模式，它可能有助于掩盖某些与I / O相关的延迟的情况，但绝对不是这样用于计算密集型工作负载）

2）参数传输的附加成本-您必须将一些数据从主流程转移到新流程。这会花费附加时间，您必须支付此附加费用，而这在原始的纯[SERIAL]工作流程中不存在。

3）结果返回传输的附加成本-您必须将一些数据从新数据移回原始过程（主过程）。这会花费附加时间，您必须支付此附加费用，而这在原始的纯[SERIAL]工作流程中不存在。

4）任何数据交换的附加成本（更好地避免在并行工作流程中使用它的任何诱因-为什么？a）它会阻塞+ b）昂贵，您必须付出更多的附加成本才能获取更多数据，您无需在纯[SERIAL]原始工作流程中付款）。




  问：为什么joblib.Parallel()比非并行计算花费更多的时间？


简而言之，由于您必须付出更多的方式来发动整个精心策划的马戏团，而不是从这种并行的工作流程组织那里得到的回报（math.sqrt( <int> )中的工作量太小，无法证明产生相对巨大的成本是合理的原始python-（main）-session的2份完整副本+舞蹈的所有编排，仅从（main）-中发送每个（<int>）-，并检索返回的每个结果（<float> ）从（joblib.Parallel（）过程）回到（main）。

您的原始基准测试时间可以对累积成本进行充分的比较，以得出相同的结果：

[SERIAL]-<iterator> feeding a [SERIAL]-processing storing into list[]:  0.51 [s]
[SERIAL]-<iterator> feeding [PARALLEL]-processing storing into list[]: 31.39 [s]

原始估计表明，仅仅浪费了一个人总是要付出的附加费用，就“浪费”了大约30.9秒来完成相同（少量）的工作。



那么，如何测量您要付多少钱……才需要付钱……？

基准，基准，基准实际代码...（原型）

如果有兴趣对这些成本进行基准测试-在 [us]中花费多长时间（即在完成任何有用的工作之前您要付多少钱）来进行1），2）或3）， there were posted benchmarking templates to test并验证这些本金自己的平台上的成本，在能够决定什么是最低工作包之前，可以证明这些不可避免的支出是合理的，并且与“ cc”相比，可以产生更大的“积极”提速（最好更大）纯- >> 1.0000原始。