Come posso misurare la velocità del codice scritto in PHP?

Come posso dire quale class di molti (che fanno tutti lo stesso lavoro) eseguire più velocemente? c'è un software per misurarlo?

Hai (alless) due soluzioni:

Quello abbastanza "ingenuo" usa il microtime (vero) prima e dopo una porzione di codice, per get quanto tempo è passato durante la sua esecuzione; altre risposte hanno detto e hanno già fornito esempi, quindi non dirò molto di più.

Questa è una buona soluzione se si desidera eseguire il benchmark di un paio di istruzioni; come confrontare due tipi di funzioni, per esempio – è meglio se fatto migliaia di volte, per assicurarsi che each "elemento perturbante" sia mediato.

Qualcosa di simile, quindi, se vuoi sapere quanto tempo ci vuole per serializzare un arrays:

$before = microtime(true); for ($i=0 ; $i<100000 ; $i++) { serialize($list); } $after = microtime(true); echo ($after-$before)/$i . " sec/serialize\n"; 

Non perfetto, ma utile e non richiede molto tempo per l'installazione.


L'altra soluzione, che funziona molto bene se si desidera identificare quale function richiede molto tempo in un integer script, è quella di utilizzare:

  • L'estensione Xdebug , per generare dati di profiling per lo script
  • Software che legge i dati di profilazione e ti offre qualcosa di leggibile. Conosco tre di questi:
    • Webgrind ; interface web ; dovrebbe funzionare su qualsiasi server Apache + PHP
    • WinCacheGrind ; solo su Windows
    • KCacheGrind ; probabilmente solo Linux e Linux-like; È quello che preferisco, btw

Per get file di profilazione, devi installare e configurare Xdebug; dare un'occhiata alla pagina Profiling PHP Scripts della documentazione.

Quello che faccio di solito non è abilitare il profiler di default (genera file abbastanza grandi e rallenta) , ma usa la possibilità di submit un parametro chiamato XDEBUG_PROFILE come dati GET, per triggersre il profiling solo per la pagina che mi serve.
La parte relativa al profiling del mio php.ini si presenta così:

 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 

(Leggi la documentazione per maggiori informazioni)

Questo screenshot proviene da un programma C ++ in KcacheGrind: http://kcachegrind.sourceforge.net/html/pics/KcgShot3Large.gif http://kcachegrind.sourceforge.net/html/pics/KcgShot3Large.gif
Otterrai esattamente lo stesso tipo di cose con gli script PHP 😉
(Con KCacheGrind, voglio dire, WinCacheGrind non è buono come KCacheGrind …)

Questo ti permette di avere una bella visione di ciò che richiede tempo nella tua applicazione e talvolta aiuta a localizzare la function che sta rallentando tutto ^^

Nota che Xdebug conta il tempo della CPU speso da PHP; quando PHP è in attesa di una risposta da un database (per esempio), non funziona; solo in attesa. Quindi Xdebug penserà che la richiesta del DB non impiegherà molto tempo!
Questo dovrebbe essere profilato sul server SQL, non su PHP, quindi …

Spero che questo sia utile 🙂
Divertiti !

Per cose veloci lo faccio (in PHP):

 $startTime = microtime(true); doTask(); // whatever you want to time echo "Time: " . number_format(( microtime(true) - $startTime), 4) . " Seconds\n"; 

Puoi anche usare un profiler come http://xdebug.org/ .

Ho fatto una semplice lezione di cronometraggio, forse è utile a qualcuno:

 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"; } } 

Uso:

 $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 

Ho usato XHProf ultimamente http://pecl.php.net/package/xhprof . È stato originariamente sviluppato da Facebook e ha un'interface web decente.

Ecco una risposta diretta alla tua domanda

c'è un software per misurarlo?

Si C'è. Mi chiedo perché qualcuno non l'abbia ancora menzionato. Anche se le risposte suggerite sopra sembrano soddisfacenti per un controllo rapido, ma non sono scalabili a lungo termine o per un progetto più grande.

Perché non utilizzare uno strumento Application Performance Monitoring (APM) creato esattamente per questo e molto altro ancora. Scopri NewRelic, AppDynamics, Ruxit (tutti hanno la versione gratuita) per monitorare il tempo di esecuzione, l'utilizzo delle risorse, la velocità effettiva di each applicazione al livello del metodo.

Mi piacerebbe condividere con voi una function autonoma che utilizzo per misurare la velocità di qualsiasi function esistente fino a 10 argomenti:

 function fdump($f_name='', $f_args=arrays()){ $f_dump=arrays(); $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_arrays($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; } 

Esempio

 function do_stuff($arg1='', $arg2=''){ return $arg1.' '.$arg2; } fdump('do_stuff',arrays('hello', 'world')); 

ritorna

  arrays(3) { ["f_success"]=> bool(true) ["f_time"]=> float(0) //too fast... ["f_result"]=> string(11) "hello world" } 

Se si desidera testare rapidamente le performance di un framework, è ansible inserire il file index.php

 //at beginning $milliseconds = round(microtime(true) * 1000); //and at the end echo round(microtime(true) * 1000) - $milliseconds; 

Ogni volta che otterrai il tempo di esecuzione in millisecondi . Perché i microsecondi non sono troppo utili per testare un caso framework.

Se è qualcosa che può essere testato al di fuori del context Web, utilizzo semplicemente il command time Unix.

Zend Studio ha integrato il supporto per la profilazione usando XDebug o ZendDebugger. Traccerà un profilo del tuo codice, che ti dirà esattamente per quanto tempo each function ha preso. È uno strumento fantastico per capire where sono i tuoi colli di bottiglia.

È ansible utilizzare elementi di base come la memorizzazione di timestamp o microtime () prima e dopo un'operazione per calcolare il tempo necessario. È facile da fare, ma non molto preciso. Forse una soluzione migliore è Xdebug , non ho mai lavorato con esso ma sembra essere il debugger / profiler PHP più conosciuto che riesca a trovare.