Question

我不明白为什么我的计算时间比使用28-30核心的时间长，而不是在AWS EC2 c3.8xlarge上使用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个（硬件）独立处理单元。

尝试在更多OS进程中并行处理CPU绑定任务与使用硬件中的处理器并行是没有意义的。事实上，由于资源开销和上下文切换（这是你所看到的），它经常是有害的。

这可能取决于您的具体应用，实验将帮助您找到最佳位置（听起来就像您已经完成的那样）。

使用多核处理的Python代码使用32个核心而不是AWS EC2上的16个核心

1 个答案: