如何在 HPC 上使用 Python 的多个 CPU？
How to use multiple CPUs with Python on a HPC?
我在 Python 从事数据分析项目，我正在使用 HPC 集群来处理我的数据。我很难让我的程序使用多个 CPU 来使其 运行 更快。这是我正在做的一个例子：
import multiprocessing as mp
import csv
def calc_function(sample-file):
# do some heavy calculation and make a dictionary about it
sample_dict = {'Name': str(sample_file), 'Info': 'blablabla'}
return sample_dict
list_of_files = [1, 2]
pool = mp.Pool( mp.cpu_count() )
with pool as p:
list_of_results = p.map(calc_function, list_of_files)
# make csv file
# add all data to csv
我发现我的作业超时，即使我给它们的时间与我根本不使用多处理时所需的时间相同或更多。
我知道这种方式不是很好，因为它依赖于整个池在保存到 csv 之前完成。我在其他问题中发现，最好将所有内容放入队列并将其写入 csv。但我也无法让它工作。
我尝试了一个 3GB 的小型数据集，在没有 mp.Pool 的情况下大约需要 40 分钟。这也是我的 SBATCH 文件，如果有帮助的话：
#SBATCH --partition=general
#SBATCH --qos=short
#SBATCH --time=1:00:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --mem=4G
#SBATCH --mail-type=BEGIN,END
conda activate main_env
srun python <my_file.py>
conda deactivate
感谢您的帮助！
Q : "How to use multiple CPUs with Python on a HPC?"
A :
Wrong,对不起,
Python不可能
( 除非从零开始总共 re-design bottom-up，Python 之父 Guido van ROSSUM 先生通常引用自己不认为可能，如果有的话，在可预见的努力和一些可接受的时间范围内）
使用更多 CPU（核心），由于基本设计 属性，因为 Python-interpreter 进程和线程都等待单个 ( a process-central，并发性主要 -A-V-O-I-D-I-N-G, MUTEX-lock作为坐标点), Global Ininterpreter Lock (a.k.a.GIL).
这就是说，无论 Python-Interpreter 进程启动的线程数量是多少，所有线程都在等待，并且只有一个线程已成功获取 GIL MUTEX-lock，它会做少量有用的工作（大约 ~ 100 ms 的可配置块）。我重复一遍，所有其他人等待，什么都不做。这主要是相反的状态，而不是 HPC 在进行计算时所追求的状态（即 High Performance C 计算 - 请注意 PERFORMANCE 等词的重音，更确切地说 HIGH 表现 ).
如果我们始终如一地使用相同的词来表达这些词的相同含义，那么将基于 Python-Interpreter 的工作发布到 HPC-infrastructure 上更接近于 High-Performance-Waiting，而不是 High-Performance-Computing（smart-vectorised non-Python、GIL-bypassing math-libraries 肯定是这个事实的光荣例外，但这些是 per-se不是Python-Interpreter，而是well-oiled和performance-optimised外部数学引擎，所以观察仍然成立）。
问题 (as-is) - 什么是...的最佳处理策略？
为
- 给定 list-of-filenames 待处理
- 将file-content转换为结果的给定过程
- 给定 HPC-infrastructure 在
上启动计算策略
解决方案
避免任何和所有 add-on 管理费用：
- 忘记队列 - Queue-handling 开销加上 data-SER/DES-overheads（阅读
pickle.dumps( sample_dict ) + pickle.loads( sample_dict ) 表示非常糟糕 anti-patterns 如果要提高性能）
- 忘记生成
mp.cpu_count()-整个 Python-Interepreter 进程中的许多 full-copies（包括所有内部 data-structures、file-handles 等，等等 ) RAM-footprint 如果这样做很快就会在现代 { 8- | 16- | 32- | 64- | ... }-core CPUs 上耗尽 physical-RAM 并将 O/S 变成 RAM-thrashing swap-in / swap-out 垂死，仅通过移动 physical-RAM 方块 from-disk-to-RAM / from-RAM-to-disk 和恶心，性能就会被消灭，留下更少的，如果有的话，残留 RAM-I/O一些（已经饿死，现在）窒息的计算的带宽。因此，已经效率低下的 ( High-Performance-Waiting ) GIL-lock 引擎现在甚至等待接收下一个 pseudo-instructions' 数据从 RAM 返回到 CPU 以便能够做一些下一个 ~ 100 毫秒的“计算”
最有前途的候选人
，表现最好Python-allowed：
如果您不能或不使用 re-factor 代码，以便绕过 GIL-lock performance-avoiding 陷阱，请执行：
a) 使用 slurm 工具启动尽可能多的 N python-processes 作为你的 HPC-usage 计划允许（Python-Interpreter 不需要任何 multi-core，策略的其他部分也不需要，right-sized RAM-specific 参数可能有助于找到更多空闲节点以将批次映射到 HPC-Infrastructure - 请参阅下面的评论 )
b) 通过 process-specific launch-configuration 参数
配置每个 slurm-launched python-process
c) self-configure 每个 python-process，基于 slurm-launch 交付的 process-specific 参数
d) 使每个 python-process 开始一个琐碎的、私有的、concurrency-avoided、embarrasingly-parallel，但仍然是一个 Python-Interpreter 原生的纯-[SERIAL] 处理那些而且只有那些文件，来自它自己的文件，给定 <_list-of-filenames_> 的 non-overlapping sub-set，第 1-of-N 开始第 1-N-th， 2nd 2nd-N-th part, 3rd 3rd-N-th, last the last-N-th of the original list.
e) 使 file-processing 函数在某些文件中 self-store 它自己的结果，无论是 .CSV 还是其他文件（ HPC-policies' 细节可以更喜欢 append-based通过 O/S-tools )
f) 最后使用 O/S 工具 ex-post ad-libidum
收集并加入生成的文件
总结：
这个秘诀完成了所有 performance-oriented 个步骤，而没有添加一条（昂贵且重复多次的）指令，并且将成为 HPC-infrastructure.
上有史以来最快的计算策略
专注于性能，此编排将最小 add-on 开销添加到纯 [SERIAL] sequential-processing，因此实现的加速将最好地扩展 N :
1
S = __________________________; where s, ( 1 - s ), N were defined above
( 1 - s ) pSO:= [PAR]-Setup-Overhead add-on
s + pSO + _________ + pTO pTO:= [PAR]-Terminate-Overhead add-on
N
有关 HPC-usage 政策和 HPC-resources / HPC-usage 配额的详细信息，请咨询您的 HPC-infrastructure 管理员和技术支持部门。
细节很重要（不同的 file-storage 文件系统，从头开始愤怒的访问/使用/删除政策可以而且将会决定最好的 pre-launch & post-completion file-manipulations 发生，以便整个 batch-process 从合法 HPC-Infrastructure 资源使用 )
这里没有其他魔法可以提供帮助。
我在 Python 从事数据分析项目，我正在使用 HPC 集群来处理我的数据。我很难让我的程序使用多个 CPU 来使其 运行 更快。这是我正在做的一个例子：
import multiprocessing as mp
import csv
def calc_function(sample-file):
# do some heavy calculation and make a dictionary about it
sample_dict = {'Name': str(sample_file), 'Info': 'blablabla'}
return sample_dict
list_of_files = [1, 2]
pool = mp.Pool( mp.cpu_count() )
with pool as p:
list_of_results = p.map(calc_function, list_of_files)
# make csv file
# add all data to csv
我发现我的作业超时，即使我给它们的时间与我根本不使用多处理时所需的时间相同或更多。
我知道这种方式不是很好，因为它依赖于整个池在保存到 csv 之前完成。我在其他问题中发现，最好将所有内容放入队列并将其写入 csv。但我也无法让它工作。
我尝试了一个 3GB 的小型数据集，在没有 mp.Pool 的情况下大约需要 40 分钟。这也是我的 SBATCH 文件，如果有帮助的话：
#SBATCH --partition=general
#SBATCH --qos=short
#SBATCH --time=1:00:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --mem=4G
#SBATCH --mail-type=BEGIN,END
conda activate main_env
srun python <my_file.py>
conda deactivate
感谢您的帮助！
Q : "How to use multiple CPUs with Python on a HPC?"
A :
Wrong,对不起,
Python不可能
( 除非从零开始总共 re-design bottom-up，Python 之父 Guido van ROSSUM 先生通常引用自己不认为可能，如果有的话，在可预见的努力和一些可接受的时间范围内）
使用更多 CPU（核心），由于基本设计 属性，因为 Python-interpreter 进程和线程都等待单个 ( a process-central，并发性主要 -A-V-O-I-D-I-N-G, MUTEX-lock作为坐标点), Global Ininterpreter Lock (a.k.a.GIL).
这就是说，无论 Python-Interpreter 进程启动的线程数量是多少，所有线程都在等待，并且只有一个线程已成功获取 GIL MUTEX-lock，它会做少量有用的工作（大约 ~ 100 ms 的可配置块）。我重复一遍，所有其他人等待，什么都不做。这主要是相反的状态，而不是 HPC 在进行计算时所追求的状态（即 High Performance C 计算 - 请注意 PERFORMANCE 等词的重音，更确切地说 HIGH 表现 ).
如果我们始终如一地使用相同的词来表达这些词的相同含义，那么将基于 Python-Interpreter 的工作发布到 HPC-infrastructure 上更接近于 High-Performance-Waiting，而不是 High-Performance-Computing（smart-vectorised non-Python、GIL-bypassing math-libraries 肯定是这个事实的光荣例外，但这些是 per-se不是Python-Interpreter，而是well-oiled和performance-optimised外部数学引擎，所以观察仍然成立）。
问题 (as-is) - 什么是...的最佳处理策略？
为
- 给定 list-of-filenames 待处理
- 将file-content转换为结果的给定过程
- 给定 HPC-infrastructure 在 上启动计算策略
解决方案
避免任何和所有 add-on 管理费用：
- 忘记队列 - Queue-handling 开销加上 data-SER/DES-overheads（阅读
pickle.dumps( sample_dict )+pickle.loads( sample_dict )表示非常糟糕 anti-patterns 如果要提高性能） - 忘记生成
mp.cpu_count()-整个 Python-Interepreter 进程中的许多 full-copies（包括所有内部 data-structures、file-handles 等，等等 ) RAM-footprint 如果这样做很快就会在现代{ 8- | 16- | 32- | 64- | ... }-core CPUs 上耗尽 physical-RAM 并将 O/S 变成 RAM-thrashing swap-in / swap-out 垂死，仅通过移动 physical-RAM 方块 from-disk-to-RAM / from-RAM-to-disk 和恶心，性能就会被消灭，留下更少的，如果有的话，残留 RAM-I/O一些（已经饿死，现在）窒息的计算的带宽。因此，已经效率低下的 ( High-Performance-Waiting ) GIL-lock 引擎现在甚至等待接收下一个 pseudo-instructions' 数据从 RAM 返回到 CPU 以便能够做一些下一个 ~ 100 毫秒的“计算”
最有前途的候选人
，表现最好Python-allowed：
如果您不能或不使用 re-factor 代码，以便绕过 GIL-lock performance-avoiding 陷阱，请执行：
a) 使用 slurm 工具启动尽可能多的 N python-processes 作为你的 HPC-usage 计划允许（Python-Interpreter 不需要任何 multi-core，策略的其他部分也不需要，right-sized RAM-specific 参数可能有助于找到更多空闲节点以将批次映射到 HPC-Infrastructure - 请参阅下面的评论 )
b) 通过 process-specific launch-configuration 参数
配置每个slurm-launched python-process
c) self-configure 每个 python-process，基于 slurm-launch 交付的 process-specific 参数
d) 使每个 python-process 开始一个琐碎的、私有的、concurrency-avoided、embarrasingly-parallel，但仍然是一个 Python-Interpreter 原生的纯-[SERIAL] 处理那些而且只有那些文件，来自它自己的文件，给定 <_list-of-filenames_> 的 non-overlapping sub-set，第 1-of-N 开始第 1-N-th， 2nd 2nd-N-th part, 3rd 3rd-N-th, last the last-N-th of the original list.
e) 使 file-processing 函数在某些文件中 self-store 它自己的结果，无论是 .CSV 还是其他文件（ HPC-policies' 细节可以更喜欢 append-based通过 O/S-tools )
f) 最后使用 O/S 工具 ex-post ad-libidum
收集并加入生成的文件总结：
这个秘诀完成了所有 performance-oriented 个步骤，而没有添加一条（昂贵且重复多次的）指令，并且将成为 HPC-infrastructure.
上有史以来最快的计算策略专注于性能，此编排将最小 add-on 开销添加到纯 [SERIAL] sequential-processing，因此实现的加速将最好地扩展 N :
1
S = __________________________; where s, ( 1 - s ), N were defined above
( 1 - s ) pSO:= [PAR]-Setup-Overhead add-on
s + pSO + _________ + pTO pTO:= [PAR]-Terminate-Overhead add-on
N
有关 HPC-usage 政策和 HPC-resources / HPC-usage 配额的详细信息，请咨询您的 HPC-infrastructure 管理员和技术支持部门。
细节很重要（不同的 file-storage 文件系统，从头开始愤怒的访问/使用/删除政策可以而且将会决定最好的 pre-launch & post-completion file-manipulations 发生，以便整个 batch-process 从合法 HPC-Infrastructure 资源使用 )
这里没有其他魔法可以提供帮助。