Nek a vu que tu avais un -1, et il en a déduit (tout seul) :
- que les gens croyait que tu disais n'importe quoi
- que c'était forcément l'oeuvre de "trolls pythonistes à deux balles"
Donc pour rétablir ton honneur de cet affront d'avoir eu un -1 non justifié il a balancé un Benchmark douteux entre PHP7 et Python3.
Pour en finir sur ce HS, perso même si je préfère Python j'ai jamais douté que PHP7 pouvait avoir de très bonne perfs. Tant mieux pour les dev PHP mais ça changera pas ma vie. De toute façon PHP et Python ont des scopes d'utilisation largement différent. Choisir un langage c'est bien plus compliqué que de se fier à des benchmark douteux. Car le bench fournit est de mauvais fois. Rien que sur le premier exemple on compare un calcul de norme spectral. Déjà je doute que beaucoup de gens font ça en PHP dans la vrai vie mais coté Python je peux vous assurer que n'importe quel dev utilisera numpy/scipy pour calculer ça.
edit:
Pour prouver que le bench n'était pas honnête, j'ai tenté d'amélioré légèrement le script Python proposé. Je n'ai pas changé la logique du programme, j'ai gardé exactement le même découpage de fonction. J'ai simplement :
- Tout passé à numpy plutot que d'utiliser des tableaux python
- Changé les deux fonctions
part_A_times_u et part_At_times_u pour qu'elles utilisent numpy
- Modifié le script principal pour l'utiliser aussi (et faire les conversions)
Il est important de noter que en voulant ne pas toucher à la logique du programme (et le découpage en fonction) je fais actuellement des allocations inutiles (entre autre les arange), des conversion aussi assez inutile (je suis pas sûrs que ça vaille le coup de distribuer ça sur des coeurs) et qu'il reste un paquet de boucle inutile (il est probable que les fonctions eval_A_times_u et eval_At_times_u pourraient être vectorisé facilement).
Voici le code avec les lignes modifié mise en évidence, la version original peut être trouvé ici:
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45 | from multiprocessing import Pool
from math import sqrt
import numpy as np
from sys import argv
def eval_A (i, j):
return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1)
def eval_A_times_u (u):
args = ((i,u) for i in range(len(u)))
return pool.map(part_A_times_u, args)
def eval_At_times_u (u):
args = ((i,u) for i in range(len(u)))
return pool.map(part_At_times_u, args)
def eval_AtA_times_u (u):
return eval_At_times_u (eval_A_times_u (u))
def part_A_times_u(xxx_todo_changeme):
(i,u) = xxx_todo_changeme
return np.sum(eval_A (i, np.arange(u.size))*u)
def part_At_times_u(xxx_todo_changeme1):
(i,u) = xxx_todo_changeme1
return np.sum(eval_A (eval_A (js, i), i)*u)
def main():
n = int(argv[1])
u = np.ones((n,))
for dummy in range (10):
v = np.array(eval_AtA_times_u (u))
u = np.array(eval_AtA_times_u (v))
vBv = np.sum(u*v)
vv = np.sum(v**2)
print("%0.9f" % (sqrt(vBv/vv)))
if __name__ == '__main__':
pool = Pool(processes=4)
main()
|
En lançant ce programme avec le même paramètre que indiqué (n=5550) je passe de :
| real 5m19.446s
user 20m37.528s
sys 0m0.216s
|
à
| real 0m9.864s
user 0m36.912s
sys 0m0.064s
|
Je vais donc a peut prêt 32.4 ((5*60+19.446)/9.864) fois plus vite. Vu le temps pris sur la machine du bench, mon code sur sa machine prendrait environ 7.7 sec (250.2/32.38503649635037) et donc on explose les 44 sec de PHP 7.
Est ce normal ? Oui ! PHP est fait pour faire du web, Python est plus généraliste et un de ces avantages est qu'il dispose d'un gros ecosystème en particulier dans le calcul scientifique. Ce n'est pas pour rien que les scientifiques se mettent a Python et non PHP. Tout dev Python sérieux aurait utilisé numpy pour ça même si il n'est pas dans la lib standard tellement il est commun. Cela ne veux pas dire que PHP7 est lent, simplement que Python avec numpy est plus rapide pour ça quand on fait les choses bien…
! Alors n'hésitez pas à l'installer.
