warum ist numba bei dieser einfachen summierung so viel schneller?

Question

Ich habe eine öffentliche Notebook wo Python, numpy, numba, cython und Fortran auf einfache Summierung verglichen werden:

https://gist.github.com/denfromufa/7727874c4fe1e7e174ed953930e93bbc

Warum ist numba so viel schneller?

Answer 1

Wie von @DavidW gezeigt, machen Sie nicht wirklich einen Vergleich von identischen Algorithmen. Im Folgenden habe ich zwei separate Funktionen für jeden Cython und Numba geschrieben, die dasselbe tun. Die erste arbeitet auf einem Array, die zweite nur eine ganze Zahl gegeben:

Cython:

cpdef long cy_sum(long[:] A): 
    cdef long i, n = A.shape[0], s = 0 
    for i in range(n): 
     s += A[i] 
    return s 

cpdef long cy_sum2(long i): 
    cdef long s, x 
    s = 0 
    for x in range(i): 
     s += x 
    return s 

Numba:

@nb.jit(nopython=True) 
def nb_sum(A): 
    s=0 
    n = A.shape[0] 
    for i in range(n): 
     s += A[i] 
    return s 

@nb.jit(nopython=True) 
def nb_sum2(i): 
    s=0 
    for x in range(i): 
     s+=x 
    return s 

Testing um sicherzustellen, dass sie die gleichen Ergebnisse liefern:

N = int(1e6) 
d = np.arange(N, dtype=np.int64) 

print np.allclose(nb_sum(d), cy_sum(d)) # True 
print np.allclose(nb_sum2(N), cy_sum2(N)) # True 

Und Timings auf meiner Hardware:

%timeit cy_sum(d) 
%timeit nb_sum(d) 

1000 loops, best of 3: 416 µs per loop 
1000 loops, best of 3: 237 µs per loop 

%timeit cy_sum2(N) 
%timeit nb_sum2(N) 

10000000 loops, best of 3: 63.5 ns per loop 
10000000 loops, best of 3: 187 ns per loop 

Ich würde nicht zu viele Schlussfolgerungen aus einem Mikro-Benchmark wie diesem ziehen, aber zumindest jetzt werden gleichwertige Implementierungen verglichen.