Tests et benchmark en PHP 5

Je souhaiterais, avant toute chose, remercier tous les membres de l'équipe PHP pour l'aide qu'ils m'ont fournie dans la rédaction de cet article.
Je remercie en particulier Yogui et Iubito sans qui je n'aurais pas pu faire cet article.

Cet article est une suite de tests que j'ai réalisés sur ma propre machine et qui permet de se faire une idée sur le temps d'exécution de telle ou telle fonction PHP.

Je tiens à préciser que cet article ne vous fera pas gagner un temps considérable si d'emblée vos pages PHP sont mal codées. Ces minioptimisations ne remplacent évidemment pas un algorithme bien pensé.

Pensez donc à améliorer les algorithmes de vos pages PHP avant même de penser à « customiser » votre code.

Les tests suivants ont été réalisés sur un serveur Apache 2.2.4 (Win32) avec la version 5.2.3 de PHP.

Pour chaque test, nous avons exécuté cinq fois le même code, à savoir une boucle de 3 millions d'itérations, ceci afin d'avoir des résultats concluants.
La boucle est la suite :

<?php
$nb_occur=3000000;

$time_start = microtime(true);

for ($i=0 ; $i<$nb_occur; $i++)
{
    //le test
}

$time_end = microtime(true);
$time = $time_end - $time_start;

echo 'Durée : '.$time.' secondes<br/>';
?>

Lorsque les conditions de tests ont été différentes pour des raisons quelconques (par exemple effectuer 3 millions de fois un echo d'un millier de caractères c'est pas très intéressant :)), je l'indique dans cet article.

Nous allons tout d'abord commencer par faire une simple affectation de chaîne de caractères à une variable pour voir la différence entre les deux temps d'exécution.

//1er cas
$chaîne='Ceci est une chaîne.'; 

//2e cas    
$chaîne="Ceci est une chaîne.";

Aucune différence notoire… passons au test suivant.

Cette fois nous affectons, en plus de la chaîne, la variable $i qui correspond au compteur des 3 millions d'itérations.

//1er cas    
$chaîne='Ceci est une variable : '.$i; 

//2e cas    
$chaîne="Ceci est une variable : ".$i;

//3e cas
$chaîne="Ceci est une variable : $i";

Voilà une différence et pas des moindres : le troisième cas met 25 % plus de temps que le premier et le second qui, eux, sont équivalents. Pourquoi ?
La raison est simple, le serveur PHP décompose la chaîne de caractères dans le troisième cas afin de trouver et interpréter la variable $i, chose qu'il ne fait pas dans les deux autres cas.
En ce qui concerne l'efficacité pure et dure, la concaténation est donc préférable à l'utilisation de variable à l'intérieur même d'une chaîne de caractères : le premier et le second cas seraient à ce moment-là ex aequo. Pas tout à fait…

En effet, il est conseillé d'utiliser les apostrophes, car elles permettent d'avoir un code largement plus lisible quand on combine PHP et HTML :

//1er cas
echo '<img src="chemin/vers/fichier/image.jpg" alt="description image" />';

//2e cas
echo "<img src=\"chemin/vers/fichier/image.jpg\" alt=\"description image\" />";

Dans le premier cas, on utilise les apostrophes pour délimiter la chaîne de caractères ce qui permet d'éviter d'échapper les guillemets dans le code HTML (ce que nous sommes obligés de faire dans le second cas).

Pour conclure, la meilleure solution est donc d'utiliser les apostrophes et de concaténer les variables : cette méthode est non seulement plus rapide, mais également plus lisible.

Nous avons d'abord fait le test entre différentes « versions » du echo (voir la documentation sur les chaînes de caractères) et le print afin de voir laquelle était la plus performante.

//1er cas
echo '. '.$i; 

//2e cas
echo '. ',$i;

//3e cas
echo <<<EOT
. $i
EOT;

//4e cas
print '. '.$i;

Bien que les temps d'exécution soient très proches les uns des autres, nous pouvons voir que la version multiparamètre du echo (2^e cas) semble être la plus performante tandis que la syntaxe HereDoc (3^e cas) a, elle, plus de mal.

Pour ce qui est du print, il est théoriquement moins rapide qu'un echo, car il retourne toujours 1 (cf. la doc. officielle de print et plus particulièrement cette brève discussion), mais nous voyons dans ce test que la différence reste infime.

J'ai voulu également répondre à une question revenant souvent sur les forums en tout genre « est-il plus rapide de faire un seul gros echo ou plusieurs petits ? ».
A priori j'aurais été le premier à répondre « un seul gros », car ce qui fait perdre du temps c'est l'envoi de flux au serveur et il vaut donc mieux envoyer un seul gros paquet que plein de petits… ce n'est pas si évident !!!

//1er cas : echo constitué de 10 caractères + 1 espace
echo 'llllllllll ';

//2e cas : echo constitué de 100 fois (10 caractères + 1 espace)
echo 'llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll llllllllll 
      llllllllll llllllllll llllllllll llllllllll ';

Pour ce test, j'ai modifié les boucles, car l'affichage 3 millions de fois de 1000 caractères est vraiment trop long.
J'ai donc réalisé deux séries : la première affichant 30 millions de caractères et la seconde affichant 1 million caractères.

La théorie est respectée : le second cas est plus rapide bien que la différence ne soit pas si importante.
Par contre, outre le fait que ce soit légèrement plus rapide d'afficher tout dans un gros bloc, c'est surtout bien plus lisible que de faire un echo par ligne comme on le voit souvent :)

Une solution autre et très efficace est d'utiliser ob_start couplé à ob_end_flush. Il faut appeler ob_start au début de vos pages PHP et ob_end_flush à la fin.
Par exemple sur notre première série (affichage de 30 millions de caractères), la durée d'exécution est de 4.90419578552 secondes soit un gain de temps de plus de 50 % !!!
Ceci s'explique, car ob_start permet d'envoyer toutes les données, qui devraient être affichées à l'écran, dans le tampon de sortie et c'est seulement lors de l'appel de ob_end_flush que les données sont restituées au navigateur.
Cela permet d'éviter les allers-retours incessants entre le serveur et le navigateur dus à la répétition des echos d'où un gain de temps plus que substantiel.

Souvent les gens utilisent la fonction is_null afin de savoir si une variable est NULL ou pas. Est-ce vraiment la meilleure solution ?

//1er cas
$i===NULL;

//2e cas
is_null($i);

Comme vous pouvez le voir la fonction is_null est deux fois plus lente que l'opérateur binaire ===.
L'utilisation d'une fonction est généralement plus gourmande en mémoire qu'un opérateur : ceci à cause de l'obligation de sauvegarder l'environnement. Donc, en plus de la perte de performances, l'utilisation de la fonction is_null consomme de la mémoire vive.
Attention tout de même à ne pas confondre une variable nulle et une autre inexistante : les deux tests ci-dessus renverront tous les deux des notices si vous testez des variables non définies auparavant dans votre code. Pour pallier ce problème, il faut utiliser les fonctions isset ou empty.

Voyons maintenant les différentes manières de déclarer et d'initialiser plusieurs variables avec la même valeur.

//1er cas    
$var1 = 'une chaîne';
$var2 = 'une chaîne';

//2e cas    
$var1 = 'une chaîne';
$var2 = $var1;

//3e cas
$var1 = $var2 = 'une chaîne';

Le temps d'exécution est quasi identique dans les trois cas. Le second et le troisième cas sont en revanche plus propres au niveau du code (en effet, si la chaîne change, il suffit de la modifier à un seul endroit).

Il est à noter que le fait de transtyper une variable augmente légèrement le temps d'exécution.

Nous avons testé ici les trois différentes manières de traiter les conditions : la structure if/elseif/else, le switch et enfin l'opérateur ternaire.
Nous avons réalisé deux jeux de tests : un jeu avec seulement deux possibilités et un autre avec huit possibilités. Le test consiste simplement à faire un modulo sur le compteur.

//1ercas
if($i%2 == 1) $test=0;
else $test=1;

//2ecas
switch($i%2)
{
case 1:
    $test=0;
    break;
default:
    $test=1;
}

//3e cas
$test = (($i%2 == 1) ? 0 : 1);

À la vue du premier jeu de tests, on pourrait dire que l'opérateur classique if/else est le plus rapide, mais voyons si on rajoute des possibilités.

//1ercas
$res=$i%8;
if($res == 0) $test=0;
elseif($res == 1) $test=1;
elseif($res == 2) $test=2;
elseif($res == 3) $test=3;
elseif($res == 4) $test=4;
elseif($res == 5) $test=5;
elseif($res == 6) $test=6;
else $test=7;

//2ecas
$res=$i%8;
switch($res)
{
   case 0:
      $test=0; break;
   case 1:
      $test=1; break;
   case 2:
      $test=2; break;
   case 3:
      $test=3; break;
   case 4:
      $test=4; break;
   case 5:
      $test=5; break;
   case 6:
      $test=6; break;
   default :
      $test=7;
}

//3e cas
$res=$i%8;
$test = ($res == 0) ? 0 : (
        ($res == 1) ? 1 : (
        ($res == 2) ? 2 : (
        ($res == 3) ? 3 : (
        ($res == 4) ? 4 : (
        ($res == 5) ? 5 : (
        ($res == 6) ? 6 : 7))))));

Si nous rajoutons des possibilités, nous pouvons voir que le switch est plus rapide que les deux autres solutions.
Ceci nous permet de conclure qu'il vaut mieux utiliser l'opérateur classique if/else quand il y a peu de possibilités et le switch quand il y en a plus.
Il est à noter que l'opérateur ternaire n'est le plus rapide dans aucun des deux jeux de tests et cela tombe bien étant donné que son code est relativement illisible.

Nous testons dans ce paragraphe, à travers deux séries de tests, trois manières de faire des boucles en PHP 5 : for, while et foreach + range.
Nous avons remplacé la boucle que nous utilisons pour tous les tests par les boucles suivantes :

//1er série : $cpt=3000000;
//2e série : $cpt=100000;

//1er cas
for($i=0; $i <$cpt; $i++) $test=$i;

//2e cas
$i=0;
while($i<$cpt) 
{
    $test=$i;
    $i++;
}

//3e cas
foreach(range(0,$cpt) as $i) $test=$i;

Le while est comme prévu la façon la plus rapide de faire une boucle, mais il est évident qu'au niveau de la lisibilité du code, le for est mieux.

Pour ce qui est du foreach + range, il est à oublier pour principalement deux raisons :

• si vous souhaitez faire de grosses boucles, vous allez tomber sur une « fatal error » (j'ai augmenté le memory_limit jusqu'à 128 Mo, mais rien n'y change) ;
• c'est long, trop long… environ trois fois plus qu'un while.

Très souvent on voit des bouts de code avec un count inséré dans le for, c'est mal ! Voyez par vous-même dans ce qui suit :

//1er cas
$k=0;
$tableau=array('a', 'b', 'c', 'd', 'e');
$n=count($tableau);
for($i=0; $i<$n; $i++) $k++;

//2e cas
$k=0;
$tableau = array('a', 'b', 'c', 'd', 'e');
for($i=0; $i<count($tableau); $i++) $k++;

Le résultat est sans appel, il faut toujours calculer la taille du tableau avant de faire une boucle.
Dans le cas contraire, cette taille est recalculée à chaque tour de boucle, ce qui est une perte de temps considérable.

Pour la lecture nous avons réalisé, à chaque fois, le même test qui consiste à ouvrir, lire puis fermer un fichier 3000 fois. Nous avons réalisé ce test sur trois fichiers : le premier de 1 octet, le second de 1Ko et le troisième de 1Mo.

VI-A-1. Dans une chaîne▲

//1er cas
$fichier=file_get_contents('test.txt'); 

//2e cas
$fp =  fopen('test.txt', 'r');
$fichier = fread($fp, filesize('test.txt'));
fclose($fp);

VI-A-2. Dans un tableau▲

//1er cas
$fichier=file_get_contents('test.txt');
$lignes = split('[\n\r]', $fichier);
 
//2e cas
$lignes=file('test.txt'); 
 
//3e cas
$fp =  fopen('test.txt', 'r');
$fichier = fread($fp, filesize('test.txt'));
fclose($fp); 
$lignes = split('[\n\r]', $fichier);

Dans cette partie, nous avons écrit de différentes façons dans un fichier.
Tout comme pour la lecture, nous avons réalisé trois séries : écriture de 1 octet, 1 Ko et enfin 1 Mo dans un fichier que l'on crée auparavant.
Nous avons réalisé 3000 fois chacune de ces opérations. La variable $a_ecrire contient la chaîne de caractères à écrire soit un caractère dans la première série, 1024 dans la seconde et 1 048 576 dans la troisième et dernière.

//1er cas
file_put_contents('test.txt', $a_ecrire); 

//2e cas
$fp =  fopen('test.txt', 'w');
fwrite($fp, $a_ecrire);
fclose($fp);

Les résultats restent donc très similaires à la lecture dans un fichier : le temps d'exécution est plus long lorsque l'on utilise la fonction file_put_contents et il augmente exponentiellement avec la taille des données à écrire.