En me penchant un peu sur les performances que l'on peut obtenir en PHP, je suis tombé sur cet article ( en anglais) fort intéressant. Il propose de comparer les différentes performances obtenu sur 2 tests à l'aide à chaque fois de 3 différents codes réalisant la même chose mais l'un utilisant de la programmation orientée objet et un autre utilisant une fonction. Les résultats sont assez explicites cependant l'article n'indique pas quelle version de php est utilisée et un " copyright 2003 "  en bas de page ne laisse rien présager de bon. J'ai donc décidé de reexecuter les tests avec le moteur PHP 5.3:

J’ai donc simplement réutilisé les codes sources proposés:

Test #1:

POO Fonction Rien
class test function one() for ($i=0; $i<1000000; $i++)
{ { {
function one() { return 1; $cnt+=1;
return 1; } }
} for ($i=0; $i<1000000; $i++)  
  {  
}    
  $cnt+=one();  
for ($i=0; $i<1000000; $i++)    
{ }  
$testclass=new test();    
$cnt+=$testclass->one();    
}    

La machine utilisée pour le test est un core 2 duo T5550 avec 2 Go de mémoire vive.

Test #1: POO Fonction Rien
1 7,788 5,168 0,317
2 7,542 5,085 0,315
3 7,528 5,172 0,316
4 7,694 5,034 0,318
5 7,518 5,009 0,316
6 7,560 5,163 0,315
7 7,692 4,955 0,313
8 7,537 4,969 0,313
9 7,518 5,006 0,319
10 7,565 4,948 0,315
Moyenne 7,594 5,051 0,316

Les résultats de premier test sont très proche de ceux de l’article originel. On peut voir que le code PHP Objet met en moyenne 2,5 secondes de plus que la simple fonction pour s’exécuter. En fait ils sont même pire que sur l’article originel. On peut objecter que ma machine est moins performante puisqu’elle ne tourne qu’à 1,66 GHz.

Cependant le delta entre le code OOP et la fonction s’est réduit, ce qui semble montrer que le temps d’exécution d’une fonction a augmenté sur les dernières versions de PHP.

Test #2:

POO Fonction Rien
class test function one() for ($i=0; $i<100000; $i++)
{ { {
     
function one() return 1; $cnt+=1;
{   $cnt+=1;
  } $cnt+=1;
return 1;   $cnt+=1;
  for ($i=0; $i<100000; $i++) $cnt+=1;
} { $cnt+=1;
    $cnt+=1;
} $cnt+=one(); $cnt+=1;
  $cnt+=one(); $cnt+=1;
for ($i=0; $i<100000; $i++) $cnt+=one(); $cnt+=1;
{ $cnt+=one();  
  $cnt+=one(); }
$testclass=new test(); $cnt+=one();  
$cnt+=$testclass->one(); $cnt+=one();  
$cnt+=$testclass->one(); $cnt+=one();  
$cnt+=$testclass->one(); $cnt+=one();  
$cnt+=$testclass->one(); $cnt+=one();  
$cnt+=$testclass->one();    
$cnt+=$testclass->one(); }  
$cnt+=$testclass->one();    
$cnt+=$testclass->one();    
$cnt+=$testclass->one();    
$cnt+=$testclass->one();    
     
}    

Comme l’indique l’article source, la principale différence de ce second test est de chercher à simuler l’exécution d’une dizaine de fonction en même temps plutôt qu’une seule. Normalement le code orienté objet doit mieux s’en sortir puisque la classe n’a besoin d’être initialisée qu’une fois pour tout les appels plutôt qu’une fois par appel comme dans le premier exemple:

Test #2: POO Fonction Rien
1 5,7443 4,7801 0,0948
2 5,6938 4,7601 0,0959
3 5,7112 4,9380 0,0942
4 5,8177 4,7591 0,0937
5 5,7281 4,9040 0,0934
5 5,8531 4,7233 0,0955
6 5,6975 4,7585 0,0952
7 5,6994 4,8630 0,0954
8 6,3116 5,3563 0,0967
9 5,6867 4,8563 0,0952
Moyenne 5,7943 4,8699 0,0950

Et effectivement on peut voir ici que le code OOP s’en sort mieux le delta est ici en moyenne de légèrement moins d’une seconde avec la fonction. En revanche encore une fois les résultats sont terriblement moins bon que sur les anciens tests. Là ou sur l’article originel le code OOP était 200% plus rapide, il ne l’est que 130% ici.

Et si PHP a amélioré ses performances ce ne semble pas être sur l’exécution des fonctions qui s’exécutaient quand même 2,5 fois plus vite avant entre le test1 et le test2 pour seulement 2 fois plus vite ici.

Par contre, l’exécution en dehors d’une fonction a explosé ! 400% plus rapide que sur les anciens tests !

Qu’en conclure ?

Certainement pas qu’il faut se passer de POO et de structures fonctionnelles, mais peut être en revanche d’éviter d’utiliser ces fonctions à l’excès et peut-être les éviter dans les rares cas ou l’on a besoin de performance et ou on peut se le permettre. On peut aussi dans ce cas se tourner vers quelque chose comme hiphop-php , xcache , eaccelerator ou même carrément witty. Egalement pour améliorer les performances de vos scripts je vous invite à consulter le site fort intéressant: http://www.phpbench.com

Ce qui est sur c’est que PHP à encore des progrès à faire quand à la gestion de la POO.