Necesito obtener una visión general del rendimiento que se puede obtener al usar Cython en código numérico de alto rendimiento. Una de las cosas que me interesa es averiguar si un compilador de C optimizador puede vectorizar el código generado por Cython. Entonces decidí escribir el siguiente pequeño ejemplo:

import numpy as np
cimport numpy as np
cimport cython

@cython.boundscheck(False)
@cython.wraparound(False)
cpdef int f(np.ndarray[int, ndim = 1] f):
    cdef int array_length =  f.shape[0]
    cdef int sum = 0
    cdef int k
    for k in range(array_length):
        sum += f[k]
    return sum

Sé que hay funciones de Numpy que hacen el trabajo, pero me gustaría tener un código fácil para comprender lo que es posible con Cython. Resulta que el código generado con:

from distutils.core import setup
from Cython.Build import cythonize

setup(ext_modules = cythonize("sum.pyx"))

y llamó con:

python setup.py build_ext --inplace

genera un código C que se ve así para el bucle:

for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2 += 1) {
  __pyx_v_sum = __pyx_v_sum + (*(int *)((char *) 
    __pyx_pybuffernd_f.rcbuffer->pybuffer.buf +
    __pyx_t_2 * __pyx_pybuffernd_f.diminfo[0].strides)));
}

El principal problema con este código es que el compilador no sabe en tiempo de compilación que__pyx_pybuffernd_f.diminfo[0].strides es tal que los elementos de la matriz están muy juntos en la memoria. Sin esa información, el compilador no puede vectorizar eficientemente.

¿Hay alguna manera de hacer algo así desde Cython?