python - Cython prange慢4线程，然后有范围

我现在正试图按照一个简单的例子来将循环与cython的prange并行。
我已经安装了openblas 0.2.14，允许使用openmp，并从源代码处编译了numpy 1.10.1和scipy 0.16。为了测试库的性能，我遵循以下示例：http://nealhughes.net/parallelcomp2/。
要计时的函数从站点复制：

import numpy as np
from math import exp
from libc.math cimport exp as c_exp
from cython.parallel import prange,parallel

def array_f(X):

    Y = np.zeros(X.shape)
    index = X > 0.5
    Y[index] = np.exp(X[index])

    return Y

def c_array_f(double[:] X):

    cdef int N = X.shape[0]
    cdef double[:] Y = np.zeros(N)
    cdef int i

    for i in range(N):
        if X[i] > 0.5:
            Y[i] = c_exp(X[i])
        else:
            Y[i] = 0

    return Y


def c_array_f_multi(double[:] X):

    cdef int N = X.shape[0]
    cdef double[:] Y = np.zeros(N)
    cdef int i
    with nogil, parallel():
        for i in prange(N):
            if X[i] > 0.5:
                Y[i] = c_exp(X[i])
            else:
                Y[i] = 0

    return Y

代码作者报告了4核的以下加速：

from thread_demo import *
import numpy as np
X = -1 + 2*np.random.rand(10000000)
%timeit array_f(X)
1 loops, best of 3: 222 ms per loop
%timeit c_array_f(X)
10 loops, best of 3: 87.5 ms per loop
%timeit c_array_f_multi(X)
10 loops, best of 3: 22.4 ms per loop

当我在我的机器（MacBook Pro with OSX 10.10）上运行这些示例时，我得到以下导出时间OMP_NUM_THREADS=1

In [1]: from bla import *
In [2]: import numpy as np
In [3]: X = -1 + 2*np.random.rand(10000000)
In [4]: %timeit c_array_f(X)
10 loops, best of 3: 89.7 ms per loop
In [5]: %timeit c_array_f_multi(X)
1 loops, best of 3: 343 ms per loop

对于OMP_NUM_THREADS=4

In [1]: from bla import *
In [2]: import numpy as np
In [3]: X = -1 + 2*np.random.rand(10000000)
In [4]: %timeit c_array_f(X)
10 loops, best of 3: 89.5 ms per loop
In [5]: %timeit c_array_f_multi(X)
10 loops, best of 3: 119 ms per loop

我在opensuse机器上看到了同样的行为，因此我提出了问题。在我的两个系统中，如果同一个代码在4个线程中运行得慢一些，作者怎么能提高4倍的速度呢？
生成*.c & .so的设置脚本也与博客中使用的脚本相同。

from distutils.core import setup
from Cython.Build import cythonize
from distutils.extension import Extension
from Cython.Distutils import build_ext
import numpy as np

ext_modules=[
    Extension("bla",
              ["bla.pyx"],
              libraries=["m"],
              extra_compile_args = ["-O3", "-ffast-math","-march=native", "-fopenmp" ],
              extra_link_args=['-fopenmp'],
              include_dirs = [np.get_include()]
              )
]

setup(
  name = "bla",
  cmdclass = {"build_ext": build_ext},
  ext_modules = ext_modules
)

如果有人能给我解释一下为什么会这样。

最佳答案

1）prange的一个重要特征（类似于其他的parallel for循环）是它激活无序执行，这意味着循环可以按任意顺序执行。无序化执行在迭代之间没有数据依赖性时确实会带来回报。
我不知道cython的内部结构，但我认为如果不关闭boundschecking，循环就不能任意执行，因为下一次迭代将取决于数组在当前迭代中是否越界，因此问题几乎变成串行的，因为线程必须等待结果。这是代码的问题之一。事实上，赛龙确实给了我以下警告：

warning: bla.pyx:42:16: Use boundscheck(False) for faster access

所以添加以下内容

from cython import boundscheck, wraparound

@boundscheck(False)
@wraparound(False)
def c_array_f(double[:] X):
   # Rest of your code

@boundscheck(False)
@wraparound(False)
def c_array_f_multi(double[:] X):
   # Rest of your code

现在让我们用你的数据X = -1 + 2*np.random.rand(10000000)计时。
带边界检查：

In [2]:%timeit array_f(X)
10 loops, best of 3: 189 ms per loop
In [4]:%timeit c_array_f(X)
10 loops, best of 3: 93.6 ms per loop
In [5]:%timeit c_array_f_multi(X)
10 loops, best of 3: 103 ms per loop

无边界检查：

In [9]:%timeit c_array_f(X)
10 loops, best of 3: 84.2 ms per loop
In [10]:%timeit c_array_f_multi(X)
10 loops, best of 3: 42.3 ms per loop

这些结果是用num_threads=4（我有4个逻辑核）得到的，速度大约是2倍。在进一步之前，我们仍然可以通过声明数组是连续的（即用ms声明X和Y）来进一步减少一些double[::1]。
连续数组：

In [14]:%timeit c_array_f(X)
10 loops, best of 3: 81.8 ms per loop
In [15]:%timeit c_array_f_multi(X)
10 loops, best of 3: 39.3 ms per loop

2）更重要的是工作“AA>，这就是你的基准受到的影响。默认情况下，块大小是在编译时确定的，例如schedule=static，但是很可能环境变量（例如OMPP时间表）和两台机器（从博客帖子中的一个）的工作负载是不同的，并且它们在运行时、动态地、导向地安排作业。让我们把prange替换为

for i in prange(N, schedule='static'):
    # static scheduling...
for i in prange(N, schedule='dynamic'):
    # dynamic scheduling...

现在让我们来看看它们（只不过是多线程代码）：
排班效果：

In [23]:%timeit c_array_f_multi(X) # static
10 loops, best of 3: 39.5 ms per loop
In [28]:%timeit c_array_f_multi(X) # dynamic
1 loops, best of 3: 319 ms per loop

根据您自己机器上的工作负载，您可能能够复制此内容。另一方面，由于您只是试图在微基准测试中测量并行VS串行代码的性能，而不是实际代码，所以建议您去掉if-else条件，即只保留for循环中的Y[i] = c_exp(X[i])。这是因为if-else语句也会对并行代码中的分支预测和无序执行产生不利影响。在我的机器上，我得到了几乎2.7倍的速度超过串行代码与这一变化。