如何找到理想数量的并行进程以使用 python 多处理运行？
Posted
技术标签:
【中文标题】如何找到理想数量的并行进程以使用 python 多处理运行？【英文标题】：How to find ideal number of parallel processes to run with python multiprocessing? 【发布时间】：2020-06-17 07:15:54 【问题描述】：尝试找出正确数量的并行进程以使用python multiprocessing 运行。
以下脚本在 8 核 32 GB (Ubuntu 18.04) 机器上运行。 （以下测试时只有系统进程和基本用户进程在运行。）
使用以下内容测试了 multiprocessing.Pool 和 apply_async：
from multiprocessing import current_process, Pool, cpu_count
from datetime import datetime
import time
num_processes = 1 # vary this
print(f"Starting at datetime.now()")
start = time.perf_counter()
print(f"# CPUs = cpu_count()") # 8
num_procs = 5 * cpu_count() # 40
def cpu_heavy_fn():
s = time.perf_counter()
print(f"datetime.now(): current_process().name")
x = 1
for i in range(1, int(1e7)):
x = x * i
x = x / i
t_taken = round(time.perf_counter() - s, 2)
return t_taken, current_process().name
pool = Pool(processes=num_processes)
multiple_results = [pool.apply_async(cpu_heavy_fn, ()) for i in range(num_procs)]
results = [res.get() for res in multiple_results]
for r in results:
print(r[0], r[1])
print(f"Done at datetime.now()")
print(f"Time taken = time.perf_counter() - starts")
结果如下：
num_processes total_time_taken
1 28.25
2 14.28
3 10.2
4 7.35
5 7.89
6 8.03
7 8.41
8 8.72
9 8.75
16 8.7
40 9.53
以下内容对我来说很有意义：
每个进程一次运行一个进程大约需要 0.7 秒，因此运行 40 应该大约需要 28 秒，这与我们上面观察到的一致。 一次运行 2 个进程应该将时间减半，这在上面观察到（~14 秒）。 一次运行 4 个进程应进一步将时间减半，这在上面观察到 (~7 秒)。 将并行度增加到超过内核数 (8) 应该会降低性能（由于 CPU 争用），并且可以观察到这种情况（有点）。没有意义的是：
为什么并行运行 8 的速度没有并行运行 4 的两倍，即为什么不是 ~3.5 秒？ 为什么一次并行运行 5 到 8 个比一次运行 4 个更糟糕？有 8 个核心，但为什么整体运行时间更差？ （当并行运行 8 个时，htop 显示所有 CPU 的利用率接近 100%。当并行运行 4 个时，其中只有 4 个处于 100%，这是有道理的。）
【问题讨论】：
您在任务管理器的性能选项卡中看到了多少个选项卡？需要更多有关您的硬件的背景信息才能回答。 我在 Ubuntu 上运行，而不是 Windows。 你在哪个 CPU 上运行它？ 它是 Standard_D8s_v3（8 vcpus，32 GiB 内存）Azure VM：docs.microsoft.com/en-us/azure/virtual-machines/dv3-dsv3-series 【参考方案1】：最可能的原因是您在使用simultaneous multithreading (SMT) 的CPU 上运行程序，在Intel 单元上更广为人知的是hyper-threading。在 wiki 之后引用，对于物理上存在的每个处理器内核，操作系统会寻址两个虚拟（逻辑）内核并尽可能在它们之间共享工作负载。这就是这里发生的事情。
您的操作系统说是 8 核，但实际上它是 SMT 的 4 核。该任务显然受 CPU 限制，因此任何超过 物理 核心数量的增加都不会带来任何好处，只会带来多处理的开销成本。这就是为什么您会看到性能几乎呈线性增长，直到达到（物理！）最大值。核心数量 (4)，然后在需要为这个 CPU 密集型任务共享核心时减少。
【讨论】：
谢谢。使用***.com/a/23378780/1333610 计算出物理内核的数量。确实是4！ @arun 优秀的链接文章。由于您是在云 VM 上运行它，因此 CPU 类型的知识无济于事。服务器 CPU 通常在 VM 之间共享，并且您正在运行的 CPU 不太可能拥有，例如10 个物理核心（但分配给您 4 个）。【参考方案2】：Q：“为什么一次并行运行 5 到 8 个比一次运行 4 个更糟糕？”
嗯，有几个原因，我们将从一个静态的、最容易观察到的原因开始：
由于 硅设计（为此他们使用了一些硬件技巧）无法扩展超过 4.
所以 最后一个 Amdahl's Law 解释并促进了从 +1 升级的 处理器 计数为 4 的加速，并且任何下一个 +1 都不会提升性能在 2, 3, 4 情况下观察到的方式相同：
这个lstopo CPU 拓扑图有助于开始解码为什么（这里是 4 核，但逻辑与你的 8 核芯片相同 - 运行 lstopo on您的设备可以在体内查看更多详细信息）：
┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ Machine (31876MB) │
│ │
│ ┌────────────────────────────────────────────────────────────┐ ┌───────────────────────────┐ │
│ │ Package P#0 │ ├┤╶─┬─────┼┤╶───────┤ PCI 10ae:1F44 │ │
│ │ │ │ │ │ │
│ │ ┌────────────────────────────────────────────────────────┐ │ │ │ ┌────────────┐ ┌───────┐ │ │
│ │ │ L3 (8192KB) │ │ │ │ │ renderD128 │ │ card0 │ │ │
│ │ └────────────────────────────────────────────────────────┘ │ │ │ └────────────┘ └───────┘ │ │
│ │ │ │ │ │ │
│ │ ┌──────────────────────────┐ ┌──────────────────────────┐ │ │ │ ┌────────────┐ │ │
│ │ │ L2 (2048KB) │ │ L2 (2048KB) │ │ │ │ │ controlD64 │ │ │
│ │ └──────────────────────────┘ └──────────────────────────┘ │ │ │ └────────────┘ │ │
│ │ │ │ └───────────────────────────┘ │
│ │ ┌──────────────────────────┐ ┌──────────────────────────┐ │ │ │
│ │ │ L1i (64KB) │ │ L1i (64KB) │ │ │ ┌───────────────┐ │
│ │ └──────────────────────────┘ └──────────────────────────┘ │ ├─────┼┤╶───────┤ PCI 10bc:8268 │ │
│ │ │ │ │ │ │
│ │ ┌────────────┐┌────────────┐ ┌────────────┐┌────────────┐ │ │ │ ┌────────┐ │ │
│ │ │ L1d (16KB) ││ L1d (16KB) │ │ L1d (16KB) ││ L1d (16KB) │ │ │ │ │ enp2s0 │ │ │
│ │ └────────────┘└────────────┘ └────────────┘└────────────┘ │ │ │ └────────┘ │ │
│ │ │ │ └───────────────┘ │
│ │ ┌────────────┐┌────────────┐ ┌────────────┐┌────────────┐ │ │ │
│ │ │ Core P#0 ││ Core P#1 │ │ Core P#2 ││ Core P#3 │ │ │ ┌──────────────────┐ │
│ │ │ ││ │ │ ││ │ │ ├─────┤ PCI 1002:4790 │ │
│ │ │ ┌────────┐ ││ ┌────────┐ │ │ ┌────────┐ ││ ┌────────┐ │ │ │ │ │ │
│ │ │ │ PU P#0 │ ││ │ PU P#1 │ │ │ │ PU P#2 │ ││ │ PU P#3 │ │ │ │ │ ┌─────┐ ┌─────┐ │ │
│ │ │ └────────┘ ││ └────────┘ │ │ └────────┘ ││ └────────┘ │ │ │ │ │ sr0 │ │ sda │ │ │
│ │ └────────────┘└────────────┘ └────────────┘└────────────┘ │ │ │ └─────┘ └─────┘ │ │
│ └────────────────────────────────────────────────────────────┘ │ └──────────────────┘ │
│ │ │
│ │ ┌───────────────┐ │
│ └─────┤ PCI 1002:479c │ │
│ └───────────────┘ │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
仔细观察，例如调用hwloc-tool：lstopo-no-graphics -.ascii，显示相互处理独立性在哪里结束 - 这里的级别为shared L1-instruction-cache（L3 也是共享的，但位于层次结构的顶部，并且大小对于大型问题解决者来说很麻烦只是，不是我们的情况）
接下来是一个更糟糕的可观察原因为什么更糟糕在 8 个进程上：
Q：“为什么并行运行 8 的速度没有并行运行 4 的两倍，即为什么不是
~3.5s？” em>
由于热管理。
加载到 CPU 内核上的工作越多，通过硅迷宫驱动 ~3.5+ GHz 上的电子产生的热量就越多。热限制是那些阻止 CPU 计算能力进一步提高性能的限制，仅仅是因为我们知道的物理定律不允许超出某些材料定义的限制。
那么接下来会发生什么？
CPU 设计规避的不是物理（那是不可能的），而是我们，用户——通过向我们承诺一个具有 ~3.5+ GHz 的 CPU 芯片（但实际上，CPU 可以使用这个时钟——仅在一小段时间内保持速率 - 直到散发的热量没有使硅接近热限制 - 然后，CPU 将决定 降低其自己的时钟频率作为过热防御步骤（这会降低性能，不是吗？）或 一些 CPU 微架构可能会跳跃（移动处理流程）到另一个免费的、因此更酷的 CPU 核心（它保持承诺更高的时钟频率那里（至少在一小段时间内）但也会降低性能，因为跳跃不会发生在零时间并且确实不会以零成本发生（缓存丢失、重新获取等）
这张图片显示了核心跳变情况的快照 - 核心 0-19 过热并且处于热节流上限之下，而核心 20-39 可以（至少目前如此）全速奔跑：
结果？
两种热约束（将 CPU 潜水到液氮池中已在“流行”杂志节目中进行了演示，但对于任何可持续计算而言，这都不是一个合理的选择，因为从深度冷冻状态变为机械应力6+ GHz 时钟频率的蒸汽形成过热器会使 CPU 主体破裂，并会导致 CPU 因破裂和机械疲劳而死机，但在少数工作负载中 - 所以这是一个禁区，由于任何（非 YouTube ***）严重意味着项目的负面投资回报率。
在体内预测试的基础上，良好的冷却和合适的工人池规模是这里唯一确定的赌注。
其他架构：
【讨论】：
哇！这是一个博士级别的答案（我需要几个小时才能理解），但是谢谢！以上是关于如何找到理想数量的并行进程以使用 python 多处理运行？的主要内容，如果未能解决你的问题，请参考以下文章