Come posso dire quale classe di molte (che fanno tutti lo stesso lavoro) vengono eseguite più velocemente? esiste un software per misurarlo?
Come posso dire quale classe di molte (che fanno tutti lo stesso lavoro) vengono eseguite più velocemente? esiste un software per misurarlo?
Risposte:
Hai (almeno) due soluzioni:
Quello abbastanza "ingenuo" sta usando il microtime (vero) prima e dopo una porzione di codice, per ottenere quanto tempo è passato durante la sua esecuzione; altre risposte lo dicevano e fornivano già esempi, quindi non dirò molto di più.
Questa è una buona soluzione se vuoi confrontare un paio di istruzioni; come confrontare due tipi di funzioni, per esempio: è meglio se fatto migliaia di volte, per assicurarsi che venga calcolata la media di ogni "elemento perturbante".
Qualcosa di simile, quindi, se vuoi sapere quanto tempo ci vuole per serializzare un array:
$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 la configurazione non richiede molto tempo.
L'altra soluzione, che funziona abbastanza bene se vuoi identificare quale funzione richiede molto tempo in un intero script, è usare:
Per ottenere file di profilatura, devi installare e configurare Xdebug; dai un'occhiata alla pagina Profiling PHP Scripts della documentazione.
Quello che faccio generalmente non è abilitare il profiler di default (genera file abbastanza grandi e rallenta le cose) , ma utilizzare la possibilità di inviare un parametro chiamato XDEBUG_PROFILE
come GET data, per attivare la profilazione solo per la pagina di cui ho bisogno.
La parte relativa alla profilazione del mio php.ini è simile a questa:
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: (fonte: sourceforge.net ) Otterrai esattamente lo stesso tipo di cose con gli script PHP ;-)
(Con KCacheGrind, voglio dire; WinCacheGrind non è buono come KCacheGrind ... )
Ciò ti consente di ottenere una buona visione di ciò che richiede tempo nella tua applicazione e talvolta aiuta definitivamente a individuare il file funzione che sta rallentando tutto ^^
Nota che Xdebug conta il tempo di CPU impiegato da PHP; quando PHP attende una risposta da un database (per esempio), non funziona; solo in attesa. Quindi Xdebug penserà che la richiesta DB non richieda molto tempo!
Questo dovrebbe essere profilato sul server SQL, non PHP, quindi ...
Spero che questo sia utile :-)
Buon divertimento!
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 utilizzare 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
echo
$echo
Aggiornamento 2020
Sono passati molti anni dall'ultima volta che ho risposto a queste domande, quindi ho pensato che questo meritasse un aggiornamento sul panorama APM.
Ecco una risposta diretta alla tua domanda
esiste un software per misurarlo?
Si C'è. Mi chiedo perché nessuno lo abbia ancora menzionato. Anche se le risposte suggerite sopra sembrano andare bene per un controllo rapido ma non sono scalabili a lungo termine o per un progetto più grande.
Perché non utilizzare uno strumento APM (Application Performance Monitoring) creato esattamente per questo e molto altro ancora. Dai un'occhiata a NewRelic, AppDynamics, Ruxit (tutti hanno una versione gratuita) per monitorare il tempo di esecuzione, l'utilizzo delle risorse, il throughput di ogni applicazione a livello di metodo.
Se vuoi testare velocemente le prestazioni di un framework, puoi metterlo nel file index.php
//at beginning
$milliseconds = round(microtime(true) * 1000);
//and at the end
echo round(microtime(true) * 1000) - $milliseconds;
Ogni volta otterrai il tempo di esecuzione in millisecondi . Perché i microsecondi non sono troppo utili per testare un case framework.
Ultimamente ho utilizzato XHProf http://pecl.php.net/package/xhprof . È stato originariamente sviluppato da Facebook e viene fornito con un'interfaccia web decente.
Vorrei condividere con voi una funzione autocostruita che utilizzo per misurare la velocità di qualsiasi funzione esistente fino a 10 argomenti:
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;
}
Esempio
function do_stuff($arg1='', $arg2=''){
return $arg1.' '.$arg2;
}
fdump('do_stuff',array('hello', 'world'));
ritorna
array(3) {
["f_success"]=>
bool(true)
["f_time"]=>
float(0) //too fast...
["f_result"]=>
string(11) "hello world"
}
Zend Studio ha il supporto integrato per la creazione di profili utilizzando XDebug o ZendDebugger. Profilerà il tuo codice, dicendoti esattamente quanto tempo ha impiegato ogni funzione. È uno strumento fantastico per capire dove sono i tuoi colli di bottiglia.
È possibile utilizzare elementi di base come memorizzare 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 ci ho mai lavorato ma sembra essere il debugger / profiler PHP più conosciuto che riesco a trovare.