Skip to main content
 首页 » 编程设计

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

2024年10月25日12fff_TT

我有一个 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 实例,然后我重复调用 Differential.reject()(以及中间的其他一些东西来实际更改 X 的值。)

我知道我可以使用 cpdef 来避免额外的包装器调用(__reject() 和 reject()),但我的测试表明这没有区别。

我的问题如下:

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

我明白访问内存是有代价的,但我没想到代码会慢那么多。

更新

按照下面的建议,更改行

cdef double x 
cdef double dx 

到

cdef float x 
cdef float dx 

消除了一些转换操作的需要,并将代码速度提高了大约 2 倍。

请您参考如下方法:

我发现了一个可以解释缓慢的问题,请注意您将 x 和 dx 创建为 double 以接收 float 值,通过更改为:

cdef float x 
cdef float dx 

我得到了 2 倍的加速,因为它避免了在 x = self.X[v] 中将 float 值转换为 double,然后在 self 中再次从 double 转换为 float .SX[k] -= dx.

您的方法似乎没有丢失缓存,我测试过使用单个数组来存储 self.X 和 self.SX 的值 通过 2*i+0 或 2*i+1 控制访问(0 for self.X 和 1 for self.SX)并且时间是相同的。