Impossible d'optimiser sans instrument de mesure. Mesurer le temps de traitement permet de :
- déterminer les opérations les plus coûteuses et donc de cibler celles qu'il faut optimiser.
- contrôler l'efficacité d'une optimisation.
L'optimisation consiste simplement à réduire le temps d'exécution d'un traitement, idéalement sans modifier le résultat du traitement. Pour mesurer le temps de traitement, il suffit de récupérer l'heure précise au début et à la fin du traitement et de faire la différence.

La récupération de l'heure précise se fait avec la fonction microtime() qui retourne l'heure système avec une précision du centième de microseconde, largement suffisante pour nous. Malheureusement le format de microtime() est particulier et une manipulation est nécessaire pour le convertir en valeur utilisable.






Nous allons créer une fonction réutilisable (car l'optimisation peut se faire sur toutes les pages de votre site) qui retourne le temps de traitement en millisecondes.
function tjs_GetTempsTraitement($timer1) {
  $timer2 = microtime();
  $timer2 = substr($timer2,strpos($timer2," ")) + substr($timer2,0,strpos($timer2," "));
  $timer1 = substr($timer1,strpos($timer1," ")) + substr($timer1,0,strpos($timer1," "));
  return round( ($timer2-$timer1) * 10000)/10;
}
Cette fonction attend en paramètre la valeur de microtime() avant le traitement.


Voici un exemple d'utilisation.
$ChronoStart = microtime(); // On enregistre l'heure serveur avant le traitement
// Ici votre traitement
// à mesurer
// Code PHP
// Requête SQL
// ....
$temps = tjs_GetTempsTraitement($ChronoStart); // Appel de la fonction après le traitement

Voici le résultat obtenu pour le traitement d'une boucle vide de 1 à 100 000 : 21.7 ms

Dans le cas où le temps de traitement est très faible, inférieur à la milliseconde, la mesure n'est pas suffisamment précise. Pour mesurer le temps de manière plus fiable, la solution est de lancer l'exécution du traitement dans une boucle de N passages.


REM1 : il existe sûrement d'autres façons de manipuler le résultat particulier de microtime(). C'est une solution parmi d'autres.
REM2 : Les versions les plus récentes de PHPMyAdmin utilisent ce principe pour afficher le temps d'exécution d'une requête SQL.

Par où commencer les optimisations ?
Une bonne pratique pour optimiser son site est d'afficher le temps de traitement total nécessaire à la génération de la page.
Attention à cette valeur, le temps indiqué peut tenir également du temps de chargement de la page.
Malgré tout cet indicateur donne une bonne idée des pages les plus longues à générer. Concentrez vous sur les pages les plus vues et les plus longues à construire.

On peut considérer qu'une page classique doit se générer en moins de 50 millisecondes. Les pages statiques peuvent être encore plus rapides.


Voici quelques pistes pour trouver les traitements souvent coûteux et faciles à optimiser.

Les includes de fichiers
Inclure un fichier de fonctions par l'instruction include ou require prend du temps : le moteur PHP doit lire le script et l'analyser. Evidemment plus le fichier à inclure est long, plus le moteur doit travailler.
La facilité de programmation consiste à inclure à chaque page tous les fichiers de fonctions, même ceux qui ne sont pas utiles.
Une bonne pratique est de n'inclure que les fichiers qui contiennent les fonctions utiles à la page.
J'ai choisi pour ma part de multiplier le nombre de fichiers à inclure avec un découpage par fonctionnalités. Généralement, cela correspond à 1 fichier avec toutes les fonctions communes à toutes les pages (gestion des sessions, de la navigation, ...) et de nombreux fichiers avec des fonctions spécifiques (forums, actus, articles, ...) qui ne sont inclus qu'au cas par cas.

On peut même aller plus loin en faisant l'include seulement au moment de l'utilisation d'une fonction.

Les boucles
Si vos scripts utilisent les boucles, vérifiez bien le contenu du traitement de la boucle et le nombre d'itérations.
Evitez dans une boucle de faire des traitements redondants. Un traitement exactement identique ne doit pas être fait dans une boucle, mais avant. Le résultat de ce traitement est enregistré dans une variable et réutilisé dans la boucle.
Les boucles n'ont pas toujours besoin d'être exécutées en totalité. Par exemple, si vous recherchez un élément dans un tableau, il faut sortir de la boucle dès que l'élément est trouvé avec l'instruction break; inutile de continuer la recherche jusqu'au dernier élément du tableau.


Entrons maintenant dans le vif du sujet, avec l'optimisation côté SQL.