Newsgroup: it.comp.www.php
Titolo: visualizzare la velocità di esecuzione degli script

Mi piacerebbe visualizzare in fase di sviluppo la velocita di esecuzione
degli script.
(un po' come fa mysql)
C'è una opzione pronta che svolge questo (e mi è sfuggita)?
Oppure uno script MOLTO leggero che calcoli questo in modo da avere una
perturbazione trascurabile sul valore restituito...?

 ha scritto nel messaggio
news:rhlI9.66453$3l.18...@twister1.libero.it...

function getmicrotime(){
 static $var_controllo = 0;
 static $tempo1;
 if ($var_controllo == 0) {
  list($usec, $sec) = explode(" ",microtime());
  $tempo1 = (float)$usec + (float)$sec;
  $var_controllo = 1;
 } else if ($var_controllo == 1) {
  list($usec, $sec) = explode(" ",microtime());
  $tempo2 = (float)$usec + (float)$sec;
  $tempo_esecuzione = $tempo2 - $tempo1;
  $var_controllo = 0;
  return $tempo_esecuzione;
 }
}
La chiami all'inizio dello script e memorizza il tempo iniziale.. la chiami
alla fine.. e ti ritorna il tempo di esecuzione..
getmicrotime();
for ($i=1;$i<1000000;$i++) {
    $k = 5+$i;
}
echo getmicrotime();

 ha scritto nel messaggio
news:bJmI9.68084$2B1.1...@twister2.libero.it...

Grazie ora la provo.
Certo, c'è da mettere il principio di indeterminazione di Heisenberg che
dice che ogniqualvolta studi una cosa, ogniqualvolta sondi un evento, la
"sonda" ti falsa l'evento...
Quindi in soldoni... senza questa funzione il tempo di esecuzione sarebbe
più piccolo, ma inconoscibile!
;-)

 ha scritto nel messaggio
news:bJmI9.68084$2B1.1...@twister2.libero.it...

Saresti anche così gentile da commentarmela?
Grazie mille
Marcello

 Saresti anche così gentile da commentarmela?
Beh.. è semplicemente adattata (per fare in modo di "memorizzarsi" il tempo
di inizio nelle chiamate dispari.. e restituire il tempo di esecuzione nelle
chiamate pari) dall'esempio che c'è sul manuale relativo alla funzione
microtime
http://it.php.net/manual/it/function.microtime.php
function getmicrotime(){
 static $var_controllo = 0; // dichiarazione di due variabili statiche..
 static $tempo1;
 if ($var_controllo == 0) {
  list($usec, $sec) = explode(" ",microtime()); //  prende secondi e
microsecondi dalla funzione microtime.. li esplode e ne assegna i valori
alle variabili $sec e $usec
  $tempo1 = (float)$usec + (float)$sec; // li somma (i valori sono espressi
entrambi in unità di secondo) dopo avere settato le variabili come tipo
float
  $var_controllo = 1; // mettiamo la variabile di controllo ad 1 così la
prossima volta esegue l'altro if
 } else if ($var_controllo == 1) {
  list($usec, $sec) = explode(" ",microtime()); // come sopra
  $tempo2 = (float)$usec + (float)$sec; // idem.. con la differenza che
questo è il tempo finale
  $tempo_esecuzione = $tempo2 - $tempo1; // fa la differenza fra tempo
finale e tempo iniziale
  $var_controllo = 0; // mettiamo la variabile di controllo a 0 così la
prossima volta esegue l'altro if
  return $tempo_esecuzione; // ritorna il tempo di esecuzione
 }

 ha scritto nel messaggio
news:84qI9.68992$2B1.1...@twister2.libero.it...

Ho capito...
Per ridurre l'effetto perturbazione di cui parlavo pensavo si potrebbe usre
una chiamata di funzione
dopo la funzione stessa, in modo da capire quanto ci mette ad eseguire la
funzione stessa.
Infine il tempo di escuzione di script che voglio rilevare sarebbe
temposcript= tempo
totale-(tempo_esecuzione_funzione*numero_chiamte_della_funzione)
che dici?

 che dici?
Che stai dando troppo peso ad un calcolo che non è già troppo preciso di
suo..
Se provi a fare qualche reload di una pagina di test otterrai.. a pariità di
script.. valori che si discostano parecchio l'uno dall'altro.
Ad esempio ho fatto girare un po' di volte questo
getmicrotime();
for ($i=1;$i<100000;$i++) {
 $k = 5+$i;
}
echo getmicrotime();
su un Athlon 2100+ (tutto meno che un test rigoroso.. sia chiaro..) ... i
risultati andavano da 2.38 secondi a 2.49
Se vuoi fare un test.. fallo su una media.. carichi per ipotesi 1000 volte
una pagina e fai una media dei tempi di esecuzione.
La chiamata a quella funzione ti richiederà qualche millesimo.. niente
rispetto all'imprecisione che ha già di suo questo metodo.
Piccolo suggerimento parzialmente collegato: se la pagina produce molto
spesso output (e se non hai esigenze che contrastino questo metodo) la
bufferizzazione della pagina porta ad un notevole incremento di prestazioni
(
http://it.php.net/manual/it/ref.outcontrol.php
).
Questo...
ob_start();
getmicrotime();
for ($i=1;$i<1000;$i++) {
 echo 5+$i."\n";
}
echo getmicrotime();
ob_end_flush();
è circa 10 volte (sempre con poco rigore...) più veloce di questo
getmicrotime();
for ($i=1;$i<1000;$i++) {
 echo 5+$i."\n";
}
echo getmicrotime();

 "sonda" ti falsa l'evento...
Solo a livello microcosmologico. Clock CPU possono essere misurati senza
intervenire sul risultato (un cosidetto 'byproduct').