具有多处理功能的 Python 代码在 AWS EC2 上使用 32 个内核比使用 16 个内核慢

Question

我不明白为什么我在 AWS EC2 c3.8xlarge 上使用 28-30 个内核时的计算时间比使用 12-16 个内核时的时间长。我做了一些测试，结果如下图所示:

https://www.dropbox.com/s/8u32jttxmkvnacd/Slika%20zaslona%202015-01-11%20u%2018.33.20.png?dl=0

最快的计算是当我使用 13 个核心时。因此，如果我使用最大内核，则与我使用 8 个 c3.8xlarge 内核的时间相同:

https://www.dropbox.com/s/gf3bevbi8dwk5vh/Slika%20zaslona%202015-01-11%20u%2018.32.53.png?dl=0

这是我使用的简化代码。

import random
import multiprocessing as mp
import threading as th
import numpy as np

x=mp.Value('f',0)
y=mp.Value('f',0)
arr=[]
tasks=[]
nesto=[]

def calculation2(some_array):
    global x, y, arr
    p=False
    a = np.sum(some_array)*random.random()
    b = a **(random.random())
    if a > x.value:
        x.value=a
        y.value=b
        arr=some_array
        p=True
    if p:
        return x.value, y.value, arr

def calculation1(number_of_pool):
    global tasks
    pool=mp.Pool(number_of_pool)
    for i in range(1,500):
        some_array=np.random.randint(100, size=(1, 4))
        tasks+=[pool.apply_async(calculation2,args=(some_array,))]

def exec_activator():
    global x, y, arr
    while tasks_gen.is_alive() or len(tasks)>0:
        try:
            task=tasks.pop(0)
            x.value, y.value, arr = task.get()
        except:
            pass

def results(task_act):
    while task_act.is_alive():
        pass
    else:
        print x.value
        print y.value
        print arr

tasks_gen=th.Thread(target=calculation1,args=(4,))
task_act=th.Thread(target=exec_activator)
result_print=th.Thread(target=results,args=(task_act,))

tasks_gen.start()
task_act.start()
result_print.start()

它的核心是 2 个计算:

• 计算 1 - 计算数组并​​为计算 2 做作业用那个数组
• 计算 2 - 计算数组外的一些计算并比较结果

代码的目标是找到计算最大值 x 的数组，并返回它的 y。这两个计算同时开始(使用线程)，因为有时会有太多数组占用太多 RAM。

我的目标是进行最快的计算。如果可能，我需要有关如何使用所有内核的建议。

如果英语不好请提前道歉。如果您需要更多信息，请询问。

Answer 1

c3.8xlarge 是 Ivy Bridge 四核系统。它使用超线程；它实际上并没有 32 个(硬件)独立处理单元。

通常没有必要尝试在比硬件中的处理器更多的操作系统进程上并行化 CPU 绑定(bind)任务。事实上，由于资源开销和上下文切换(这就是您所看到的)，它通常是有害的。

这可能取决于您的具体应用，实验将帮助您找到最佳点(听起来您已经做到了)。