相关疑难解决方法(0)

在主机上运行多个具有相同名称的进程.使用python或jython通过名称获取这些进程的PID的跨平台方法是什么？

1. 我想要像pidofpython 一样的东西.(pidof反正我也没有.)
2. 我无法解析,/proc因为它可能不可用(在HP-UX上).
3. 我不想运行os.popen('ps')和解析输出,因为我觉得它很难看(字段顺序可能在不同的操作系统中有所不同).
4. 目标平台是Solaris,HP-UX和其他平台.

注意:请仔细阅读此问题.我知道CPython有GIL.对于大多数功能,Numpy通常不受GIL的限制.

更新:结果与此问题中描述的问题相同.如果你将numpy链接到OpenBLAS,它会在你导入numpy时立即设置整个过程的CPU亲和力.这可以通过OpenBLAS构建的标志来修复.

我的应用程序使用numpy,我从源代码构建(即没有easy_install等).通常,我的自定义构建工作正常.最近,我做了一些事(我的构建？到我的操作系统？),这阻止了numpy使用多个CPU内核.

考虑这个简单的程序,它执行以下操作:

• 在工作线程中运行愚蠢的工作负载.
• 在两个并行线程中再次运行相同的工作负载两次.

在正常工作的numpy安装中,第二个(并行)步骤几乎与第一步一样快.但在我的特殊构建中,第二步需要两倍的时间!仅使用1个CPU.它表现得好像numpy.sqrt不释放GIL,但我知道它应该.

男人,我不知道如何打破这样的numpy构建,即使我想.它拒绝使用超过1个CPU核心!我是怎么做到的？我如何解决它？

编辑:更多细节:numpy-1.7.0,gcc,Linux(Fedora 16),但我不认为这些细节太重要了.我之前使用此配置构建而没有遇到此问题.我想我想知道是否有特定的操作系统或python设置会导致这样的行为.

import numpy, threading, time

a1 = numpy.random.random((500,500,200)).astype(numpy.float32)
a2 = numpy.random.random((500,500,200)).astype(numpy.float32)
a3 = numpy.random.random((500,500,200)).astype(numpy.float32)

def numpy_workload(name, a):
    print "starting numpy_workload " + name
    for _ in range(10):
        numpy.sqrt(a)
    print "finished numpy_workload " + name

t1 = threading.Thread(target=lambda: numpy_workload("1", a1))
t2 = threading.Thread(target=lambda: numpy_workload("2", a2))
t3 = threading.Thread(target=lambda: numpy_workload("3", a3))

start = time.time()
t1.start()
t1.join()
stop = time.time()
print "Single thread done after {} …

我试图使用多处理运行一个简单的测试.测试工作正常,直到我导入numpy(即使它没有在程序中使用).这是代码:

from multiprocessing import Pool
import time
import numpy as np #this is the problematic line


def CostlyFunc(N):
    """"""
    tstart = time.time()
    x = 0
    for i in xrange(N):
        for j in xrange(N):
            if i % 2: x += 2
            else: x -= 2       
    print "CostlyFunc : elapsed time %f s" % (time.time() - tstart)
    return x

#serial application
ResultList0 = []
StartTime = time.time()
for i in xrange(3):
    ResultList0.append(CostlyFunc(5000))
print "Elapsed time (serial) : ", time.time() - StartTime


#multiprocessing …

所以,我玩弄multiprocessing.Pool和Numpy,但似乎我错过了一些重要的一点.为什么pool版本慢得多？我查看了htop,我可以看到创建了几个进程,但它们共享一个CPU,最多可达100%.

$ cat test_multi.py 
import numpy as np
from timeit import timeit
from multiprocessing import Pool


def mmul(matrix):
    for i in range(100):
        matrix = matrix * matrix
    return matrix

if __name__ == '__main__':
    matrices = []
    for i in range(4):
        matrices.append(np.random.random_integers(100, size=(1000, 1000)))

    pool = Pool(8)
    print timeit(lambda: map(mmul, matrices), number=20)
    print timeit(lambda: pool.map(mmul, matrices), number=20)

$ python test_multi.py 
16.0265390873
19.097837925

[更新]

• 改为timeit基准测试流程
• init池,包含许多核心
• 改变计算,以便有更多的计算和更少的内存传输(我希望)

仍然没有变化.pool版本仍然较慢,我可以看到htop,只使用了一个核心,也产生了几个进程. …

我一直在玩numba和numexpr试图加速一个简单的元素矩阵乘法.我无法获得更好的结果,它们基本上(速度方向)等同于numpys乘法函数.这个地区有人有运气吗？我使用numba和numexpr是错误的(我对此很新)或者这是一个不好的方法来尝试加快速度.这是一个可重现的代码,谢谢你的高级:

import numpy as np
from numba import autojit
import numexpr as ne

a=np.random.rand(10,5000000)

# numpy
multiplication1 = np.multiply(a,a)

# numba
def multiplix(X,Y):
    M = X.shape[0]
    N = X.shape[1]
    D = np.empty((M, N), dtype=np.float)
    for i in range(M):
        for j in range(N):
            D[i,j] = X[i, j] * Y[i, j]
    return D

mul = autojit(multiplix)
multiplication2 = mul(a,a)

# numexpr
def numexprmult(X,Y):
    M = X.shape[0]
    N = X.shape[1]
    return ne.evaluate("X * Y")

multiplication3 = numexprmult(a,a) 

我正在尝试使用标准python文档中的代码片段来学习如何使用多处理模块.代码将粘贴在此消息的末尾.我在Ubuntu 11.04上使用Python 2.7.1在四核机器上(根据系统监视器,由于超线程而给我八个核心)

问题:尽管已启动多个进程,但所有工作负载似乎只安排在一个核心上,接近100%的利用率.有时,所有工作负载都迁移到另一个核心,但工作负载从不在它们之间分配.

任何想法为什么会这样？

最好的祝福,

保罗

#
# Simple example which uses a pool of workers to carry out some tasks.
#
# Notice that the results will probably not come out of the output
# queue in the same in the same order as the corresponding tasks were
# put on the input queue.  If it is important to get the results back
# in the original order then consider using `Pool.map()` or
# `Pool.imap()` (which …

我遇到了一个我无法解释的奇怪问题.我希望那里有人可以帮忙!

我正在运行Python 2.7.3和Scipy v0.14.0,我正在尝试实现一些非常简单的多处理器算法来加速使用该模块的代码multiprocessing.我已经设法做了一个基本的例子:

import multiprocessing
import numpy as np
import time
# import scipy.special


def compute_something(t):
    a = 0.
    for i in range(100000):
        a = np.sqrt(t)
    return a

if __name__ == '__main__':

    pool_size = multiprocessing.cpu_count()
    print "Pool size:", pool_size
    pool = multiprocessing.Pool(processes=pool_size)

    inputs = range(10)

    tic = time.time()
    builtin_outputs = map(compute_something, inputs)
    print 'Built-in:', time.time() - tic

    tic = time.time()
    pool_outputs = pool.map(compute_something, inputs)
    print 'Pool    :', time.time() - tic

这很好,返回

Pool size: 8
Built-in: 1.56904006004
Pool …

我有一台机器有24个物理核心(至少我被告知)运行Debian : Linux 3.2.0-4-amd64 #1 SMP Debian 3.2.68-1+deb7u1 x86_64 GNU/Linux. 这似乎是正确的:

usr@machine:~/$ cat /proc/cpuinfo  | grep processor
processor   : 0
processor   : 1
<...>
processor   : 22
processor   : 23

我试图用Python加载所有内核时遇到了一些问题multiprocessing.pool.Pool.我用过Pool(processes=None); 文档说Python使用cpu_count()if None提供.

唉,只有8个核心100%加载,其他核心闲置(我用来htop监控CPU负载).我以为我无法正常烹饪Pools并尝试"手动"调用24个进程:

print 'Starting processes...'
procs = list()
for param_set in all_params:  # 24 items
    p = Process(target=_wrap_test, args=[param_set])
    p.start()
    procs.append(p)

print 'Now waiting for them.'
for p in procs: …

我已经创建了一个(相当大的)程序,需要很长时间才能完成,我开始研究加速程序的方法.

我发现如果我在程序运行时打开任务管理器,则只使用一个核心.

经过一些研究,我找到了这个网站: 为什么多重处理在导入numpy后只使用一个核心？这提供了一个解决方案os.system("taskset -p 0xff %d" % os.getpid()),但这对我不起作用,我的程序继续在单核上运行.

然后我发现这个: python是否能够在多个内核上运行？,指向使用多处理.

因此,在研究了多处理之后,我遇到了关于如何使用它的纪录片https://docs.python.org/3/library/multiprocessing.html#examples

我试过这段代码:

from multiprocessing import Process

def f(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

a = input("Finished")

运行代码后(不是在IDLE中)它说:

Finished
hello bob
Finished

注意:说完之后我第一次按下回车

所以在此之后我现在更加困惑,我有两个问题

第一:它仍然没有多核运行(我有一个8核Intel i7)

第二:为什么在它甚至运行if语句代码之前输入"Finished"(它甚至还没有完成!)

我正在尝试并行化一些numpy在Python multiprocessing模块的帮助下使用的计算.考虑这个简化的例子:

import time
import numpy

from multiprocessing import Pool

def test_func(i):

    a = numpy.random.normal(size=1000000)
    b = numpy.random.normal(size=1000000)

    for i in range(2000):
        a = a + b
        b = a - b
        a = a - b

    return 1

t1 = time.time()
test_func(0)
single_time = time.time() - t1
print("Single time:", single_time)

n_par = 4
pool = Pool()

t1 = time.time()
results_async = [
    pool.apply_async(test_func, [i])
    for i in range(n_par)]
results = [r.get() for r in results_async]
multicore_time …