Dopo aver parlato di un confronto performance fra Julia, R, Python, MATLAB, vediamo ora un altro benchmark interessante: risoluzione numerica dell'integrale definito di una funzione gaussiana, confronto di prestazioni fra i seguenti linguaggi:
- C, codice standard
- C, codice ottimizzato
- Python 3.9.2
- MATLAB (GNU Octave 6.2.0)
- JavaScript (script in HTML su Chromium 104.0.5112.101)
- PHP 7.4.30
È stato fatto uso di una funzione per misurare il tempo di esecuzione del codice in secondi (end-start), 10 campionamenti per ogni caso, poi fatta la media e riportati i valori graficamente, normalizzandoli con C_opt (l'algoritmo scritto in C "ottimizzato"); quindi C_opt ha valore 1, gli altri più sono elevati e più sono inefficienti per risolvere questo algoritmo computazionale, richiedono quindi tempo maggiore. Infine l'immagine mostra tutti i risultati e il grafico di benchmark. Sistema operativo Linux Parrot OS 5.1, 64bit (Kernel Linux 5.18.0-14parrot1-amd64 x86_64).
Riportiamo di seguito il codice nei vari casi:
- C, codice standard:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
float f(float x);
int main(){
clock_t start = clock();
float ris=0;
int N=1000000;
float a=0;
float b=20;
float h=(b-a)/N;
int i;
for(i=0;i<N;i++){
ris+=h*f(a+i*h);
}
clock_t end = clock();
printf("%f\n",(float)(end-start)/CLOCKS_PER_SEC);
return 0;
}
float f(float x){
return pow(1/(2*M_PI),0.5)*pow(M_E,(-0.5*x*x));
}
- C, codice ottimizzato (C_opt):
#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")
- MATLAB (GNU Octave 6.2.0):
clear all
close all
clc
tic
ris=0;
N=1000000;
a=0;
b=20;
h=(b-a)/N;
for i=0:N
ris=ris+1/(2*3.141592653589793)^0.5*2.718281828459045^(-0.5*(a+i*h)*(a+i*h));
end
toc
- JavaScript (script all'interno di una pagina HTML):
<html>
<script>
var start=performance.now();
var ris=0;
var N=10**6;
var a=0;
var b=20;
var h=(b-a)/N;
function f(x){
return 1/(2*3.141592653589793)**0.5*2.718281828459045**(-0.5*x**2)
}
for(i=0;i<N;i++){
ris+=h*f(a+i*h);
}
var end=performance.now();
document.write("ris="+ris+"<br>")
document.write(end-start+"ms")
</script>
</html>
- PHP 7.4.30:
<?php
$start=microtime(TRUE);
$ris=0;
$N=10**6;
$a=0;
$b=20;
$h=($b-$a)/$N;
function f($x){
return 1/(2*3.141592653589793)**0.5*2.718281828459045**(-0.5*$x**2);
}
for($i=0;$i<$N;$i++){
$ris+=$h*f($a+$i*$h);
}
$end=microtime(TRUE);
echo "ris=".$ris."\n";
echo $end-$start."s";
?>
I risultati sono mostrati nella seguente immagine: mostra chiaramente che le performance migliori sono ottenute da C (sia "ottimizzato" che "standard"), PHP e JavaScript risultano accettabili, Python e MATLAB (GNU Octave) risultano estremamente inefficienti (67 e 92 volte più lenti del codice C ottimizzato).
Interessante anche la deviazione standard dei campionamenti, il tempo di esecuzione di C, così come PHP, ha bassa variabilità, valori sempre molto simili; JavaScript e MATLAB hanno più variabilità, Python ancora molta più variabilità.
Risultati (normalizzando rispetto a C_opt):
- C_opt = 1
- C, standard = 1,2367
- Python = 67,16
- MATLAB = 92,463
- JavaScript = 3,84
- PHP = 2,6289
