丘比特比矮子慢

Question

我试图用cupy而不是numpy来加速我的python代码。这里的问题是，使用cupy，我的代码变得非常慢。也许我在这个问题上有点天真了。

也许任何人都能在我的代码中找到瓶颈：

import cupy as np
import time as ti

def f(y, t):
    y_ = np.zeros(2 * N_1*N_2) # n: e-6, c: e-5
    for i in range(0, N_1*N_2):
        y_[i] = y[i + N_1*N_2] # n: e-7, c: e-5 or e-6
    for i in range(N_1*N_2):
        sum = -4*y[i] # n: e-7, c: e-7 after some statements e-5
        if (i + 1 in indexes) and (not (i in indi)):
            sum += y[i+1] # n: e-7, c: e-7 after some statements e-5
        if (i - 1) in indexes and (i % N_1 != 0):
            sum += y[i-1] # n: e-7, c: e-7 after some statements e-5
        if i + N_1 in indexes:
            sum += y[i+N_1] # n: e-7, c: e-7 after some statements e-5
        if i - N_1 in indexes:
            sum += y[i-N_1] # n: e-7, c: e-7 after some statements e-5
        y_[i + N_1*N_2] = sum

    return y_

def k_1(y, t, h):
    return np.asarray(f(y, t)) * h

def k_2(y, t, h):
    return np.asarray(f(np.add(np.asarray(y) , np.multiply(1/2 , k_1(y, t, h))), t + 1/2 * h)) * h

# k_2, k_4 look just like k_2, may be with an 1/2 here or there

# some init stuff is happening here

while t < T_end:
    # also some magic happening here which is just data saving
    y = np.asarray(y) + 1/6*(k_1(y, t, m) + 2*k_2(y, t, m) + 2*k_3(y, t, m) + k_4(y, t, m))
    t += m

编辑，我试图对我的代码进行基准测试，下面是一些结果，它们可以被看作是代码中的注释。每个数字保持一条线。单位是秒。n: Numpy，c:CuPy，我主要是给出订单的粗略估计。另外，我测试了

np.multiply # n: e-6, c: e-5

和

np.add # n: e-5 or e-6, c: 0.005 or e-5

Answer 1

代码之所以慢并不是因为numpy慢，而是因为您调用了许多( python )函数，而调用函数(以及迭代和访问对象，基本上是python中的所有内容)在python中都是缓慢的。因此，cupy不会对您有所帮助(但可能会损害性能，因为它必须做更多的设置，例如将数据复制到gpu)。如果您能够使用更少的python函数(如另一个答案那样的矢量化)，这将极大地加速您的代码(您可能不需要cupy)。

您还可以查看南巴，它在本机代码中使用llvm编译代码。如果您这样做，一定要阅读一些文档化并使用nopython=True，否则您将只切换慢速numba代码的慢立方体代码。

Answer 2

您的代码示例不起作用，因为您没有在任何地方定义N_1、N_2、indexes和indi。此外，您在代码中的评论似乎无助于帮助其他人理解正在发生的事情。您的代码可能不会受益于numba/cupy，因为您还没有将代码中的操作向量化。从目前的代码工作方式来看，列表可能与numpy数组一样快。

如果你摆脱了你的for循环和改变

y_ = np.zeros(2 * N_1*N_2)
for i in range(0, N_1*N_2):
    y_[i] = y[i + N_1*N_2] 

至

n = N1*N2
y_ = np.zeros(2*n)
y_[:n] = y[n:2*n]

诸如此类，您将大大加快代码的速度。