Comment puis-je dire quelle classe parmi plusieurs (qui font toutes le même travail) s'exécute plus rapidement? existe-t-il un logiciel pour mesurer cela?
Comment puis-je dire quelle classe parmi plusieurs (qui font toutes le même travail) s'exécute plus rapidement? existe-t-il un logiciel pour mesurer cela?
Réponses:
Vous avez (au moins) deux solutions:
Le plus "naïf" utilise microtime (vrai) pour avant et après une partie du code, pour obtenir le temps écoulé pendant son exécution; d'autres réponses disaient cela et donnaient déjà des exemples, donc je n'en dirai pas beaucoup plus.
C'est une bonne solution si vous voulez comparer quelques instructions; comme comparer deux types de fonctions, par exemple - c'est mieux si cela est fait des milliers de fois, pour s'assurer que tout "élément perturbateur" est moyenné.
Quelque chose comme ça, donc, si vous voulez savoir combien de temps il faut pour sérialiser un tableau:
$before = microtime(true);
for ($i=0 ; $i<100000 ; $i++) {
serialize($list);
}
$after = microtime(true);
echo ($after-$before)/$i . " sec/serialize\n";
Pas parfait, mais utile, et cela ne prend pas beaucoup de temps à mettre en place.
L'autre solution, qui fonctionne assez bien si vous voulez identifier quelle fonction prend beaucoup de temps dans un script entier, est d'utiliser:
Pour obtenir des fichiers de profilage, vous devez installer et configurer Xdebug; jetez un œil à la page Profiling PHP Scripts de la documentation.
Ce que je fais généralement, ce n'est pas d'activer le profileur par défaut (il génère des fichiers assez gros et ralentit les choses) , mais utilise la possibilité d'envoyer un paramètre appelé en XDEBUG_PROFILE
tant que données GET, pour activer le profilage uniquement pour la page dont j'ai besoin.
La partie liée au profilage de mon php.ini ressemble à ceci:
xdebug.profiler_enable = 0 ; Profiling not activated by default
xdebug.profiler_enable_trigger = 1 ; Profiling activated when requested by the GET parameter
xdebug.profiler_output_dir = /tmp/ouput_directory
xdebug.profiler_output_name = files_names
(Lire la documentation pour plus d'informations)
Cette capture d'écran provient d'un programme C ++ dans KcacheGrind: (source: sourceforge.net ) Vous obtiendrez exactement le même genre de chose avec les scripts PHP ;-)
(Avec KCacheGrind, je veux dire; WinCacheGrind n'est pas aussi bon que KCacheGrind ... )
Cela vous permet d'avoir une belle vue de ce qui prend du temps dans votre application - et cela aide parfois définitivement à localiser la fonction qui ralentit tout ^^
Notez que Xdebug compte le temps CPU passé par PHP; lorsque PHP attend une réponse d'une base de données (par exemple), cela ne fonctionne pas; attendre seulement. Donc Xdebug pensera que la requête DB ne prend pas beaucoup de temps!
Cela devrait être profilé sur le serveur SQL, pas sur PHP, donc ...
J'espère que cela vous sera utile :-)
Amusez-vous bien!
Pour des choses rapides, je fais ceci (en PHP):
$startTime = microtime(true);
doTask(); // whatever you want to time
echo "Time: " . number_format(( microtime(true) - $startTime), 4) . " Seconds\n";
Vous pouvez également utiliser un profileur comme http://xdebug.org/ .
J'ai fait un cours de chronométrage simple, peut-être que c'est utile à quelqu'un:
class TimingHelper {
private $start;
public function __construct() {
$this->start = microtime(true);
}
public function start() {
$this->start = microtime(true);
}
public function segs() {
return microtime(true) - $this->start;
}
public function time() {
$segs = $this->segs();
$days = floor($segs / 86400);
$segs -= $days * 86400;
$hours = floor($segs / 3600);
$segs -= $hours * 3600;
$mins = floor($segs / 60);
$segs -= $mins * 60;
$microsegs = ($segs - floor($segs)) * 1000;
$segs = floor($segs);
return
(empty($days) ? "" : $days . "d ") .
(empty($hours) ? "" : $hours . "h ") .
(empty($mins) ? "" : $mins . "m ") .
$segs . "s " .
$microsegs . "ms";
}
}
Utilisation:
$th = new TimingHelper();
<..code being mesured..>
echo $th->time();
$th->start(); // if it's the case
<..code being mesured..>
echo $th->time();
// result: 4d 17h 34m 57s 0.00095367431640625ms
echo
mal tapé: c'est , pas$echo
Mise à jour 2020
Cela fait de nombreuses années que je n'ai pas répondu à ces questions pour la dernière fois, j'ai donc pensé que cela méritait une mise à jour sur le paysage APM.
Voici une réponse directe à votre question
existe-t-il un logiciel pour mesurer cela?
Oui il y a. Je me demande pourquoi personne ne l'a encore mentionné. Bien que les réponses suggérées ci-dessus semblent bonnes pour une vérification rapide, mais ne sont pas évolutives à long terme ou pour un projet plus important.
Pourquoi ne pas utiliser un outil APM (Application Performance Monitoring) spécialement conçu pour cela et bien plus encore. Découvrez NewRelic, AppDynamics, Ruxit (tous ont une version gratuite) pour surveiller le temps d'exécution, l'utilisation des ressources, le débit de chaque application au niveau de la méthode.
Si vous souhaitez tester rapidement les performances d'un framework, vous pouvez mettre dans le fichier index.php
//at beginning
$milliseconds = round(microtime(true) * 1000);
//and at the end
echo round(microtime(true) * 1000) - $milliseconds;
Chaque fois, vous obtiendrez le temps d'exécution en millisecondes . Parce que les microsecondes ne sont pas trop utiles pour tester un cas de cadre.
J'ai récemment utilisé XHProf http://pecl.php.net/package/xhprof . Il a été développé à l'origine par Facebook et il est livré avec une interface Web décente.
Je voudrais partager avec vous une fonction que j'utilise pour mesurer la vitesse de toute fonction existante jusqu'à 10 arguments:
function fdump($f_name='', $f_args=array()){
$f_dump=array();
$f_result='';
$f_success=false;
$f_start=microtime();
$f_start=explode(' ', $f_start);
$f_start=$f_start[1] + $f_start[0];
if(function_exists($f_name)){
if(isset($f_args[0])&&is_array($f_args[0])){
if($f_result=$f_name($f_args)){
$f_success=true;
}
}
elseif(!isset($f_args[1])){
if($f_result=$f_name($f_args[0])){
$f_success=true;
}
}
elseif(!isset($f_args[2])){
if($f_result=$f_name($f_args[0],$f_args[1])){
$f_success=true;
}
}
elseif(!isset($f_args[3])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2])){
$f_success=true;
}
}
elseif(!isset($f_args[4])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3])){
$f_success=true;
}
}
elseif(!isset($f_args[5])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4])){
$f_success=true;
}
}
elseif(!isset($f_args[6])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5])){
$f_success=true;
}
}
elseif(!isset($f_args[7])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6])){
$f_success=true;
}
}
elseif(!isset($f_args[8])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6],$f_args[7])){
$f_success=true;
}
}
elseif(!isset($f_args[9])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6],$f_args[7],$f_args[8])){
$f_success=true;
}
}
elseif(!isset($f_args[10])){
if($f_result=$f_name($f_args[0],$f_args[1],$f_args[2],$f_args[3],$f_args[4],$f_args[5],$f_args[6],$f_args[7],$f_args[8],$f_args[9])){
$f_success=true;
}
}
}
$f_end=microtime();
$f_end=explode(' ', $f_end);
$f_end=$f_end[1] + $f_end[0];
$f_time=round(($f_end - $f_start), 4);
$f_dump['f_success']=$f_success;
$f_dump['f_time']=$f_time;
$f_dump['f_result']=$f_result;
var_dump($f_dump);exit;
//return $f_result;
}
Exemple
function do_stuff($arg1='', $arg2=''){
return $arg1.' '.$arg2;
}
fdump('do_stuff',array('hello', 'world'));
Retour
array(3) {
["f_success"]=>
bool(true)
["f_time"]=>
float(0) //too fast...
["f_result"]=>
string(11) "hello world"
}
Zend Studio a intégré la prise en charge du profilage à l'aide de XDebug ou ZendDebugger. Il profilera votre code, vous indiquant exactement combien de temps chaque fonction a pris. C'est un outil fantastique pour déterminer où se trouvent vos goulots d'étranglement.
Vous pouvez utiliser des éléments de base comme le stockage des horodatages ou microtime () avant et après une opération pour calculer le temps nécessaire. C'est facile à faire, mais pas très précis. Peut-être qu'une meilleure solution est Xdebug , je n'ai jamais travaillé avec mais il semble être le débogueur / profileur PHP le plus connu que je puisse trouver.