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

Question

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

Answer 1

Hai (almeno) due soluzioni:

L'piuttosto una "ingenua" sta usando microtime (vero) tobefore e dopo una porzione di codice, per ottenere quanto tempo è passato durante la sua esecuzione; altre risposte hanno detto e hanno già fornito esempi, quindi non dirò molto altro

Questa è una buona soluzione se si desidera eseguire il benchmark di un paio di istruzioni, ad esempio confrontare due tipi di funzioni, ad esempio: è meglio se migliaia fatto di volte, per assicurarsi che qualsiasi "elemento perturbating" è in media

Qualcosa di simile a questo, quindi, se volete 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 non ci vuole molto tempo per impostare

---

L'altra soluzione, che funziona abbastanza bello se si vuole identificare quale funzione prende un sacco di tempo in un intero script, è quello di utilizzare:

• Il Xdebug estensione, per generare dati di profilatura per lo script
• Software che legge i dati di profilazione e presenta qualcosa di leggibile. Ne conosco tre:
  • Webgrind; interfaccia web ; dovrebbe funzionare su qualsiasi server Apache + PHP
  • WinCacheGrind; solo su windows
  • KCacheGrind; probabilmente solo Linux e Linux-like; Questo è quello che preferisco, btw

Per ottenere profiling i file, è necessario installare e configurare Xdebug; dare un'occhiata alla pagina Profiling PHP Scripts della documentazione.

Quello che in genere non è abilitare il profiler di default (che genera abbastanza file di grandi dimensioni, e rallenta le cose), ma utilizzare la possibilità di inviare un parametro chiamato XDEBUG_PROFILE come ottenere i dati, per attivare il profiling solo per il pagina di cui ho bisogno.
La parte profilazione legate 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 

(Leggere la documentazione per maggiori informazioni)

Questo screenshot 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 consente di ottenere una bella vista di ciò che richiede tempo nella vostra applicazione - ed a volte sicuramente aiuta a localizzare la funzione che sta rallentando tutto giù ^^

Nota che Xdebug conta il tempo di 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 profilata sul server SQL, non PHP, in modo da ...

Spero che questo è utile :-)
Buon divertimento!

Answer 2

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

Answer 3

Per roba rapido faccio questo (in PHP):

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

È inoltre possibile utilizzare un profiler come http://xdebug.org/.

Answer 4

È possibile 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.

Answer 5

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

Answer 6

Sto usando XHProf ultimamente http://pecl.php.net/package/xhprof. È stato originariamente sviluppato da Facebook e ha un'interfaccia web decente.

Answer 7

mi piacerebbe condividere con voi una funzione di self made io uso 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')); 

Returns

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

Answer 8

Ho creato una classe di temporizzazione semplice, forse 'S 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"; 
    } 

} 

Usa:

$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 

Answer 9

Se si desidera prestazioni test rapido di un quadro, si può mettere in index.php file di

//at beginning 
$milliseconds = round(microtime(true) * 1000); 

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

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

Answer 10

Qui c'è una risposta diretta alla tua domanda

è un software per misurare questo?

Sì, 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 ogni applicazione al livello del metodo.