Français
Français
Dans le processus de réglage des performances PHP, il est très important de mesurer avec précision le temps d'exécution et la consommation de ressources des scripts. Une pratique courante consiste à combiner les deux fonctions de MicroTime () et GetUsage () pour surveiller l'exécution du script et l'utilisation des ressources système. Cependant, cette méthode est-elle vraiment fiable? Cet article discutera en détail de la façon dont ces deux sont utilisés et de leur précision.
MicroTime () renvoie la partie microsecondes de l'horodatage UNIX actuel, qui est souvent utilisé pour le moment de haute précision. Une utilisation typique consiste à l'appeler une fois au début du script, puis à l'appeler une fois à la fin. La soustraction des deux entraînera le temps d'exécution du script.
<?php
$start = microtime(true);
// Opération de temps de simulation
usleep(500000); // 500millisecondes
$end = microtime(true);
$elapsed = $end - $start;
echo "Temps d'exécution du script: {$elapsed} Deuxième\n";
?>
L'avantage de cette approche est qu'il est simple et simple et a une précision suffisante pour mesurer les performances de la plupart des scripts PHP.
GetUsage () renvoie un tableau d'utilisation actuelle des ressources de processus, y compris le temps du processeur utilisateur, le temps du processeur système, l'utilisation de la mémoire, etc. couramment utilisé pour une analyse de performances granulaires plus fine.
<?php
$usage_start = getrusage();
// Opération de temps de simulation
usleep(500000);
$usage_end = getrusage();
$user_cpu_start = $usage_start["ru_utime.tv_sec"] + $usage_start["ru_utime.tv_usec"] / 1e6;
$user_cpu_end = $usage_end["ru_utime.tv_sec"] + $usage_end["ru_utime.tv_usec"] / 1e6;
$user_cpu_time = $user_cpu_end - $user_cpu_start;
echo "Statut de l'utilisateurCPUtemps: {$user_cpu_time} Deuxième\n";
?>
En calculant le décalage horaire du processeur de l'état utilisateur, nous pouvons connaître le temps nécessaire au processeur pour traiter réellement le script, plutôt que le temps d'exécution global qui inclut le temps d'attente.
Quelqu'un utilisera les deux pour juger les performances du script:
Utilisez MicroTime () pour calculer le temps total (temps de blocage mural)
Utilisez GetUsage () pour calculer le temps du processeur (état utilisateur + état système)
Exemple de code:
<?php
$start_time = microtime(true);
$start_usage = getrusage();
// Opération de temps de simulation
usleep(500000);
$end_time = microtime(true);
$end_usage = getrusage();
$elapsed_time = $end_time - $start_time;
$user_cpu_start = $start_usage["ru_utime.tv_sec"] + $start_usage["ru_utime.tv_usec"] / 1e6;
$user_cpu_end = $end_usage["ru_utime.tv_sec"] + $end_usage["ru_utime.tv_usec"] / 1e6;
$user_cpu_time = $user_cpu_end - $user_cpu_start;
$system_cpu_start = $start_usage["ru_stime.tv_sec"] + $start_usage["ru_stime.tv_usec"] / 1e6;
$system_cpu_end = $end_usage["ru_stime.tv_sec"] + $end_usage["ru_stime.tv_usec"] / 1e6;
$system_cpu_time = $system_cpu_end - $system_cpu_start;
echo "Consommation de temps totale: {$elapsed_time} Deuxième\n";
echo "utilisateurCPUtemps: {$user_cpu_time} Deuxième\n";
echo "systèmeCPUtemps: {$system_cpu_time} Deuxième\n";
?>
MicroTime () mesure la durée du temps réel, y compris tous les temps d'attente et de blocage.
GetUsage () reflète le temps de traitement réel du processeur, peut éliminer le temps d'attente tel que les E / S, et refléter de manière plus réaliste l'occupation des ressources du processeur par le script.
La combinaison des deux peut vous donner une compréhension plus complète de l'efficacité d'exécution du script et de la charge du système.
GetUsage () n'est pas pris en charge par tous les systèmes d'exploitation, et PHP sur Windows Systems ne prend pas en charge entièrement cette fonction.
getUsage () ne mesure que les ressources de processus actuelles et ne peut pas couvrir la consommation de ressources des appels externes ou des processus enfants.
Lorsque le script contient une grande quantité de demande d'attente d'E / S ou de réseau, le temps du CPU est loin du temps réel et GetUsage () ne peut pas refléter le goulot d'étranglement d'E / S.
MicroTime () est affecté par la précision de l'horloge du système et les mesures en très peu de temps peuvent être inexactes.
Pour les scripts PHP à forte intensité de processeur, la combinaison des deux mesures peut fournir des informations de performance plus précises.
Pour les scripts à forte intensité d'E / S, l'utilisation de getTrusage () n'est pas suffisante pour refléter les performances globales, et MicroTime () est plus important.
Il est recommandé de combiner d'autres outils de performance (tels que XDebug, Blackfire, etc.) pour une analyse complète.
Faites attention aux problèmes de compatibilité lors de l'utilisation de getTrusage () , en particulier dans les environnements multiplateformes.
GetUsage () et MicroTime () ont leurs propres avantages, et la combinaison d'utilisation peut en effet évaluer les performances des scripts PHP plus attentivement. Mais si cela est fiable dépend du scénario d'utilisation spécifique, de la nature du script et de l'environnement de test. Ce sont les outils de base pour l'analyse des performances, et non les balles d'argent omnipotentes. Ce n'est qu'en combinant les caractéristiques commerciales et davantage d'indicateurs de performance peuvent être jugés scientifiquement jugés et optimisés.
