为什么在Cython中写入C数组这么慢？

Question

我有一个Cython类，类似下面的人工示例：

cdef class Differential:

  cdef int *SX
  cdef int *X
  cdef int nmax

  def __init__(self, int nmax):

    self.nmax = nmax ## usually around 10*1000

    return

  def __cinit__(self, int nmax, *arg, **args):

    self.SX = <float *>malloc(nmax*cython.sizeof(float))

    ## assume self.X has some content.
    self.X = <float *>malloc(nmax*cython.sizeof(float)) 

    return

  def __dealloc__(self):

    free(self.SX)
    free(self.X)

    return

  @cython.wraparound(False)
  @cython.boundscheck(False)
  @cython.nonecheck(False)
  @cython.cdivision(True)
  cdef void __reject(self, float step) nogil:

    cdef unsigned int v
    cdef unsigned int k

    cdef double x
    cdef double dx

    float_array_init(self.SX,1000,0.) ## writes 0. to the 100000 first elements

    for v in range(1000):

      x = self.X[v]

      for k in range(v+1,1000):

        dx = x-self.X[k]

        # the following line is the "problem":
        self.SX[k] -= dx

    ## some more code
    # manipulate SX some more. this section has less performance impact because it
    # is not a double for-loop, so i have not included it in the example

    # update X
    for v in range(1000):
      self.X[v] += self.SX[v]

def reject(self, float step):
  self.__reject(step)

代码涉及的内容要多得多，但我已尝试将其剥离到最低限度，以说明我的代码流。你知道吗

在我的主脚本中，我只是创建了一个Differential的实例，然后反复调用差速器拒绝（）（以及在这两者之间的其他一些事情来实际改变X的值。）

我知道我可以使用cpdef来避免额外的包装器调用（\uuureject（）和reject（）），但是我的测试表明这没有什么区别。你知道吗

我的问题如下：

当我注释掉self.SX[k] -= dx行时，代码似乎加快了大约10倍。这是意料之中的吗？

我知道访问内存是有代价的，但我没想到代码会慢那么多。你知道吗

更新

如下所示，更改行

cdef double x
cdef double dx

至

cdef float x
cdef float dx

消除了一些强制转换操作的需要，并将代码的速度提高了大约2倍。你知道吗

Answer 1

我发现了一个可以解释这种缓慢的问题，请注意，您创建x和dx作为double来接收float值，方法是更改为：

cdef float x
cdef float dx

我得到了2倍的加速，因为它避免了在x = self.X[v]中将浮点值转换为双精度，然后在self.SX[k] -= dx中将双精度转换为浮点值。你知道吗

似乎您的方法没有丢失缓存，我测试了使用一个数组来存储self.X和self.SX的值，方法是通过2*i+0或2*i+1（0用于self.X和1用于self.SX来控制访问，时间是相同的。你知道吗