Hey Luca, let's break down why your Cython port only gave a measly 15% speedup—when you’ve got lots of loops, there’s almost always more juice to squeeze out of Cython. Here are the key issues to fix and actionable steps to get those big performance gains:

1. You’re Missing (or Skipping) Critical Type Annotations #

Cython’s biggest speed gains come from eliminating Python object overhead—but it can’t do that if you don’t explicitly define types for variables, function arguments, and array elements. A basic port without typing is just Python loops in a fancy wrapper.

Example Fix: #

Instead of a half-typed function:

def compute_gradient(input_arr):
    cdef int i, j
    output = np.zeros_like(input_arr)
    for i in range(input_arr.shape[0]):
        for j in range(input_arr.shape[1]):
            output[i,j] = input_arr[i,j] * 2 + input_arr[i-1,j]  # Slow Python-level access

Use full typing + memoryviews for direct C-level access:

import numpy as np
cimport numpy as np
from cython cimport boundscheck, wraparound

# Disable safety checks (trust your loop logic!) for extra speed
@boundscheck(False)
@wraparound(False)
def compute_gradient(np.ndarray[np.double_t, ndim=2] input_arr):
    cdef int rows = input_arr.shape[0]
    cdef int cols = input_arr.shape[1]
    # Pre-allocate typed output array
    cdef np.ndarray[np.double_t, ndim=2] output = np.zeros((rows, cols), dtype=np.float64)
    # Memoryviews skip Python object lookups for every element access
    cdef double[:,:] input_view = input_arr
    cdef double[:,:] output_view = output

    cdef int i, j
    for i in range(1, rows):  # Skip first row to avoid out-of-bounds
        for j in range(cols):
            output_view[i,j] = input_view[i,j] * 2.0 + input_view[i-1,j]
    return output

2. You’re Still Calling Numpy Functions Inside Loops #

If your loop uses numpy operations (like np.mean() or np.sum()) on small slices, you’re paying the cost of Python function calls every single iteration. Replace these with inline C-level calculations instead.

Example Fix: #

Instead of:

# Inside loop: slow numpy call per iteration
output[i,j] = np.mean(input_arr[i-2:i+3, j-2:j+3])

Compute the mean manually with C loops:

cdef double total = 0.0
cdef int count = 0
cdef int di, dj
for di in range(-2, 3):
    for dj in range(-2, 3):
        if 0 <= i+di < rows and 0 <= j+dj < cols:
            total += input_view[i+di, j+dj]
            count +=1
output_view[i,j] = total / count

3. You’re Not Using Aggressive Compiler Optimizations #

Cython relies on your C compiler to optimize the generated code. If you don’t enable flags like -O3 and -march=native, you’re leaving massive performance on the table.

Example setup.py Snippet: #

from setuptools import setup
from Cython.Build import cythonize
import numpy as np

setup(
    ext_modules=cythonize(
        "gradient_func.pyx",
        compiler_directives={"language_level": "3"},
    ),
    include_dirs=[np.get_include()],
    # Enable maximum optimizations for your CPU
    extra_compile_args=["-O3", "-march=native", "-ffast-math"],
    extra_link_args=["-O3"],
)

4. You’re Using Numpy Array Indexing Instead of Memoryviews #

Direct numpy array indexing inside loops still triggers Python object lookups. Cython memoryviews (double[:,:]) let you access array elements directly at the C level—this alone can double or triple your loop speed.

5. You’re Creating Python Objects Inside Inner Loops #

Avoid making Python floats, lists, or tuples inside your tightest loops. Use C-level variables (cdef double temp, cdef int k) instead—every Python object creation adds overhead that stacks up fast.

• Added full type annotations for all variables, function arguments, and arrays
• Disabled bounds checking/wraparound with @boundscheck(False) and @wraparound(False)
• Replaced numpy calls inside loops with manual C calculations
• Enabled -O3 and -march=native in compiler flags
• Using memoryviews for all array access inside loops
• Eliminated Python object creation in inner loops

After applying these changes, you should see a 10-100x speedup depending on how loop-heavy your function is—way better than the 15% you’re seeing now.

内容的提问来源于stack exchange，提问作者Luca