相关疑难解决方法(0)

我不确定这是否更像是一个操作系统问题,但我想我会问这里,以防任何人从Python的结尾有一些见解.

我一直在尝试使用一个CPU密集型for循环joblib,但是我发现不是将每个工作进程分配给不同的核心,我最终将它们全部分配到同一个核心而没有性能提升.

这是一个非常简单的例子......

from joblib import Parallel,delayed
import numpy as np

def testfunc(data):
    # some very boneheaded CPU work
    for nn in xrange(1000):
        for ii in data[0,:]:
            for jj in data[1,:]:
                ii*jj

def run(niter=10):
    data = (np.random.randn(2,100) for ii in xrange(niter))
    pool = Parallel(n_jobs=-1,verbose=1,pre_dispatch='all')
    results = pool(delayed(testfunc)(dd) for dd in data)

if __name__ == '__main__':
    run()

...这是我在htop脚本运行时看到的内容:

我在一台4核的笔记本电脑上运行Ubuntu 12.10(3.5.0-26).显然joblib.Parallel是为不同的工作者生成单独的进程,但有没有办法让这些进程在不同的内核上执行？

我知道这可能看起来像一个荒谬的问题,但我必须定期在计算服务器上运行工作,我与部门中的其他人分享,当我开始10个工作时,我真的希望它只需要10个核心而不是更多; 我不关心每次运行一个核心需要多长时间:我只是不希望它侵占其他人的领域,这需要我重新安排工作等等.我只想拥有10个实心核心,就是这样.

更具体地说,我在Redhat上使用Enthought 7.3-1,它基于Python 2.7.3和numpy 1.6.1,但问题更为笼统.我一直在谷歌搜索这个问题的某种答案几个小时无济于事,所以如果有人知道numpy的转换可以关闭多线程,请告诉我.

我花了几个小时来尝试并行化我的数字运算代码,但是当我这样做时它只会变慢.不幸的是,当我尝试将其减少到下面的示例时,问题就消失了,我真的不想在这里发布整个程序.所以问题是:在这类程序中我应该避免哪些陷阱？

(注意:Unutbu的答案在底部后跟进.)

以下是情况:

• 它是关于一个模块,它定义了一个BigData包含大量内部数据的类.在该示例中,存在一个ff插值函数列表; 在实际的程序,还有更多,例如ffA[k],ffB[k],ffC[k].
• 计算将被归类为"令人尴尬的并行":可以一次在较小的数据块上完成工作.在这个例子中,那是do_chunk().
• 在我的实际程序中,示例中显示的方法将导致最差的性能:每个块大约1秒(在单个线程中完成的实际计算时间的0.1秒左右).因此,对于n = 50,do_single()将在5秒内do_multi()运行并且将在55秒内运行.
• 我还尝试通过将xi和yi数组切割成连续的块并迭代k每个块中的所有值来分解工作.这工作得更好一点.现在,无论是使用1,2,3或4个线程,总执行时间都没有差别.但当然,我希望看到实际的加速!
• 这可能是相关的:Multiprocessing.Pool使Numpy矩阵乘法更慢.但是,在程序的其他地方,我使用了一个多处理池进行更加孤立的计算:一个看起来类似的函数(没有绑定到类),def do_chunk(array1, array2, array3)并对该数组进行仅限于numpy的计算.在那里,有显着的速度提升.
• CPU使用率随着预期的并行进程数量而变化(三个线程的CPU使用率为300%).

#!/usr/bin/python2.7

import numpy as np, time, sys
from multiprocessing import Pool
from scipy.interpolate import RectBivariateSpline

_tm=0
def stopwatch(msg=''):
    tm = time.time()
    global _tm
    if _tm==0: _tm = tm; return
    print("%s: %.2f seconds" % (msg, tm-_tm))
    _tm = tm

class …

我正在尝试使用Python的multiprocessing.Pool模块优化我的代码,但我没有得到我逻辑上期望的加速结果.

我正在做的主要方法涉及计算大量向量的矩阵向量积和固定的大稀疏矩阵.下面是一个玩具示例,它执行我需要的,但随机矩阵.

import time
import numpy as np
import scipy.sparse as sp

def calculate(vector, matrix = None):
    for i in range(50):
        v = matrix.dot(vector)
    return v

if __name__ == '__main__':
    N = 1e6
    matrix = sp.rand(N, N, density = 1e-5, format = 'csr')
    t = time.time()
    res = []
    for i in range(10):
        res.append(calculate(np.random.rand(N), matrix = matrix))    
    print time.time() - t

该方法在大约30几秒钟内终止.

现在,由于每个元素的计算results不依赖于任何其他计算的结果,因此很自然地认为并行计算将加速该过程.我们的想法是创建4个流程,如果每个流程都进行一些计算,那么所有流程完成所需的时间应该减少一些因素4.为此,我编写了以下代码:

import time
import numpy as np
import scipy.sparse as …