Benchmark performance C, Python, Cython

Giulio_M

Dopo aver introdotto Cython, installazione e usabilità un po' macchinosa per avvicinare l'efficienza del codice Python a quella di C/C++, vediamo un benchmark interessante. Avevamo già fatto un Benchmark performance C, Python, MATLAB - GNU Octave, JavaScript, PHP, quindi, mantenendo gli stessi dati di partenza per avere un confronto, vediamo ora i casi oggetto di studio:

C, codice ottimizzato
Python 3.9.2
Cython, caso 1
Cython, caso 2

Nel caso di Cython, dato che la procedura è piuttosto macchinosa, funziona così:

file setup.py con il seguente script:

from setuptools import setup
from Cython.Build import cythonize
setup(
    ext_modules = cythonize("test.pyx") #test.pyx è il nome da assegnare poi al file Cython
)

file Cython (test.pyx), con il codice che vediamo in seguito

starter.py, creato ad-hoc, che contiene:

import time
import test #il file cython viene gestito come un modulo da includere
start=time.time()
test.f(1000000) #richiama la funzione f() nel file test.pyx
end=time.time()
print(end-start,"s")

da terminale compiliamo il file Cython:

python3 setup.py build_ext --inplace

vengono creati dei file extra nella directory di lavoro, li lasciamo così come sono

da terminale, sempre nella directory di lavoro, possiamo lanciare il programma (file Python che richiama il codice nel file Cython) ovvero:

python3 starter.py

Riportiamo il codice per i vari casi:

C, ottimizzato:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
int main(){
clock_t start = clock();
register int N=1000000;
register float ris=0;
register float a=0;
register float b=20;
register float h=(b-a)/N;
register int i;
for(i=0;i<N;i++){
ris+=pow(1/(2*M_PI),0.5)*pow(M_E,(-0.5*(a+i*h)*(a+i*h)));
}
clock_t end = clock();
printf("%f\n",(float)(end-start)/CLOCKS_PER_SEC);
return 0;
}

Python 3.9.2:

import time
import numpy as np
start=time.time()
ris=0
N=10**6
a=0
b=20
h=(b-a)/N
def f(x):
    return 1/(2*np.pi)**0.5*np.exp(-x**2/2)
for i in range(0,N):
    ris+=h*f(a+i*h)
print("ris=",ris)
end=time.time()
print(end-start,"s")

Cython, caso 1 (file test.pyx):

import numpy as np
def f(int N):
    ris=0
    a=0
    b=20
    h=(b-a)/N
    for i in range(N):
        ris+=h/(2*np.pi)*np.exp(-0.5*(a+i*h)**2)
    return ris

Cython, caso 2 (file (test.pyx):

import numpy as np
def f(int N):
    ris=0
    cdef int a=0
    cdef int b=20
    cdef float h=(b-a)/N
    for i in range(N):
        ris+=h/(2*np.pi)*np.exp(-0.5*(a+i*h)**2)
    return ris

Come risultati, per il caso in esame (una maggiore "ottimizzazione" del codice Cython potrebbe portare ancora a qualche piccolo miglioramento) si nota comunque un miglioramento rispetto a Python. Certo, se in termini di tempo di esecuzione C=1, Python=67, Cython=50 (circa 49 o 51 a seconda del codice). Quindi la supremazia di C in termini di performance, resta sempre irraggiungibile.

benchmark-performance-C-python-cython, risoluzione numerica integrale definito

Giulio_M

Aggiornamento:
risultati notevolmente più efficienti si ottengono in questo modo:

evitare l'inclusione della libreria Numpy di Python, per scrivere np.pi e np.exp(), molto più efficiente definire i valori 3.141592653589793 e 2.718281828459045, con il numero di cifre decimali desiderato (anziché andare a richiamarli dalla libreria, ad ogni iterazione del ciclo!)
scrivere il codice Cython direttamente "ibrido" in Python, più scomodo da leggere e come sintassi, ma risulta più efficiente (meglio rispetto a richiamare diversi file Python; tuttavia, la compilazione di Cython seguendo anche gli altri accorgimenti, è ciò che genera il risultato migliore in assoluto!)

CASO 1: codice solo Python

import time
start=time.time()
ris=0
N=10**6
a=0
b=20
h=(b-a)/N
def f(x):
    return 1/(2*3.141592653589793)**0.5*2.718281828459045**(-x**2/2)
for i in range(0,N):
    ris+=h*f(a+i*h)
end=time.time()
print(end-start,"s")

CASO 2: codice Cython incluso in Python

import time
import cython
def f(N: cython.int):
    ris=0
    a: cython.int
    a=0
    b: cython.int
    b=20
    h=(b-a)/N
    for i in range(N):
        ris+=h/(2*3.141592653589793)**0.5*2.718281828459045**(-0.5*(a+i*h)**2)
    return ris
start=time.time()
f(1000000)
end=time.time()
print(end-start,"s")

Risultati: il caso 1, solo file Python (scritto senza includere la libreria Numpy) ha un tempo di esecuzione di circa 0,48 secondi. il caso 2, codice Cython incluso all'interno del singolo file Python, ha un tempo di esecuzione di circa 0,31 secondi.

Ricordiamo che i precedenti banchmark hanno mostrato Python con Numpy 2,95 secondi (67 volte più lento rispetto a C ottimizzato) e Cython 2,2 secondi, circa 50 volte più lento rispetto a C.

In questo caso invece abbiamo Python senza Numpy 0,48 secondi ovvero 10,9 volte più lento rispetto a C (NB da 67 a 10, ottimo miglioramento!!) e Cython incluso in Python che genera un tempo di 0,31 secondi significa 7,04 volte più lento rispetto a C.

Questa accortezza permette quindi di ottenere risultati decisamente migliori!

Fondatori