temps d'execution : Python vs Fortran
Bonjour,
Comme j'en ai déjà parlé, j'ai un code qui s'exécute pratiquement 100 fois plus vite en Fortran qu'en Python ...
Cet écart important me surprend car j'utilise numpy qui, je crois, accélère les calculs ...
J'ai fait un essai sur un bout de code très simple que j'exécute un million de fois et dont je mesure le temps d'exécution ...
verdict : 0,48 secondes en Fortran pour 9,23 secondes en Python/Numpy; soit pratiquement un facteur 40 :calim2:
Et sans Numpy, le code Python met 325 secondes soit un facteur 700 !!!:mrgreen::mrgreen:
voici le bout de code en Python :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| # -*- coding: cp1252 -*-
import numpy as np
from time import *
# creation de 5 arrays Numpy
dimension = 40
f = np.ndarray(shape =(dimension),dtype=np.float)
h = np.ndarray(shape =(dimension),dtype=np.float)
w = np.ndarray(shape =(dimension),dtype=np.float)
e = np.ndarray(shape =(dimension),dtype=np.float)
t = np.ndarray(shape =(dimension),dtype=np.float)
# remplissage des arrays Numpy
h.fill (10.)
w.fill (1000.)
e.fill (290.)
t.fill (300.)
t1 = time() # recuperation du temps système
i = 0
while (i < 1000000): # execution de un million de calcul
f = h * w * ( e - t ) # calcul
i = i +1
print 'temps pour un million de passages:', (time() - t1) |
Et pour ceux qui lisent le Fortran, le même en Fortran, les opérations Numpy sont remplacées par des boucles :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| USE DFPORT
implicit none
real t1, t2
real temps(2)
integer n, i, j
! déclaration de 5 tableaux
parameter (n=40)
real f(n),h(n), w(n), e(n), t(n)
! remplissage des tableaux
do i = 1,n
h(i) = 10.
w (i) = 1000.
e (i) = 290.
t (i) = 300.
enddo
t1= dtime(temps) ! récupération du temps système avant calcul
do i = 1, 1000000 ! boucle pour un million de calcul
do j = 1, n ! boucle remplaçant les opérations Numpy
f(j) = h(j) * w(j) * ( e(j) - t(j) )
enddo
enddo
t2 = dtime(temps) ! récupération du temps système après calcul
write (6,*) 'temps pour un million de passages:',temps(1) + temps(2)
end |
N'y a t-il pas moyen de faire plus rapide avec Python?
En utilisant Numpy, je m'attendais à avoir quelque chose 2 à 3 fois plus lent que Fortran mais j'étais loin de penser à un facteur 40 à 100 :cry::cry:
Est ce normal?
Est ce que je fais quelque chose de mal?
Bon dimanche
