saber - Manera precisa de medir los tiempos de ejecución de scripts php

saber el tiempo de ejecucion php

Question

Quiero saber cuántos milisegundos tarda un PHP for-loop en ejecutarse.

Conozco la estructura de un algoritmo genérico, pero no tengo idea de cómo implementarlo en PHP:

Begin
init1 = timer(); // where timer() is the amount of milliseconds from midnight
the loop begin
some code
the loop end
total = timer() - init1;
End

Answer 1

Aquí es un método muy simple y corto.

<?php
$time_start = microtime(true);
//the loop begin
//some code
//the loop end
$time_end = microtime(true);
$total_time = $time_end - $time_start;
echo $total_time; // or whatever u want to do with the time
?>

Answer 2

Aquí hay una función que multiplica la ejecución de cualquier fragmento de código PHP, al igual que lo hace el módulo timeit de Python: https://gist.github.com/flaviovs/35aab0e85852e548a60a

Cómo usarlo:

include(''timeit.php'');
const SOME_CODE = ''
strlen("foo bar");
'';
$t = timeit(SOME_CODE);
print "$t[0] loops; $t[2] per loop/n";

Resultado:

$ php x.php
100000 loops; 18.08us per loop

Descargo de responsabilidad: Soy el autor de este Gist

EDIT: timeit ahora es un proyecto independiente y autónomo en https://github.com/flaviovs/timeit

Answer 3

Aquí hay una implementación que devuelve segundos fraccionarios (es decir, 1.321 segundos)

/**
* MICROSECOND STOPWATCH FOR PHP
*
* Class FnxStopwatch
*/
class FnxStopwatch
{
/** @var float */
private $start,
$stop;
public function start()
{
$this->start = self::microtime_float();
}
public function stop()
{
$this->stop = self::microtime_float();
}
public function getIntervalSeconds() : float
{
// NOT STARTED
if (empty($this->start))
return 0;
// NOT STOPPED
if (empty($this->stop))
return ($this->stop - self::microtime_float());
return $interval = $this->stop - $this->start;
}
/**
* FOR MORE INFO SEE http://us.php.net/microtime
*
* @return float
*/
private static function microtime_float() : float
{
list($usec, $sec) = explode(" ", microtime());
return ((float)$usec + (float)$sec);
}
}

Answer 4

Crear archivo loadtime.php

<?php
class loadTime{
private $time_start = 0;
private $time_end = 0;
private $time = 0;
public function __construct(){
$this->time_start= microtime(true);
}
public function __destruct(){
$this->time_end = microtime(true);
$this->time = $this->time_end - $this->time_start;
echo "Loaded in $this->time seconds/n";
}
}

En el comienzo de su script, después de <?php write, include ''loadtime.php''; $loadtime=new loadTime(); include ''loadtime.php''; $loadtime=new loadTime();

Cuando la página se carga al final, se escribirá "Cargado en x segundos"

Answer 5

Pensé que iba a compartir la función que pongo juntos. Esperemos que te pueda ahorrar tiempo.

Originalmente se usó para rastrear el tiempo de un guión basado en texto, por lo que la salida está en forma de texto. Pero puedes modificarlo fácilmente a HTML si lo prefieres.

Hará todos los cálculos por usted sobre cuánto tiempo ha pasado desde el inicio de la secuencia de comandos y en cada paso. Formatea toda la salida con 3 decimales de precisión. (Hasta milisegundos.)

Una vez que lo copie en la parte superior de su script, todo lo que haga es poner las llamadas a la función recordTime después de cada parte que desee medir.

Copia esto en la parte superior de tu archivo de script:

$tRecordStart = microtime(true);
header("Content-Type: text/plain");
recordTime("Start");
function recordTime ($sName) {
global $tRecordStart;
static $tStartQ;
$tS = microtime(true);
$tElapsedSecs = $tS - $tRecordStart;
$tElapsedSecsQ = $tS - $tStartQ;
$sElapsedSecs = str_pad(number_format($tElapsedSecs, 3), 10, " ", STR_PAD_LEFT);
$sElapsedSecsQ = number_format($tElapsedSecsQ, 3);
echo "//".$sElapsedSecs." - ".$sName;
if (!empty($tStartQ)) echo " In ".$sElapsedSecsQ."s";
echo "/n";
$tStartQ = $tS;
}

Para rastrear el tiempo que pasa, solo haz:

recordTime("What We Just Did")

Por ejemplo:

recordTime("Something Else")
//Do really long operation.
recordTime("Really Long Operation")
//Do a short operation.
recordTime("A Short Operation")
//In a while loop.
for ($i = 0; $i < 300; $i ++) {
recordTime("Loop Cycle ".$i)
}

Da salida de esta manera:

// 0.000 - Start
// 0.001 - Something Else In 0.001s
// 10.779 - Really Long Operation In 10.778s
// 11.986 - A Short Operation In 1.207s
// 11.987 - Loop Cycle 0 In 0.001s
// 11.987 - Loop Cycle 1 In 0.000s
...
// 12.007 - Loop Cycle 299 In 0.000s

¡Espero que esto ayude a alguien!

Answer 6

Puede utilizar REQUEST_TIME desde la matriz superglobal $_SERVER . De la documentación :

''TIEMPO REQUERIDO''
La marca de tiempo del inicio de la solicitud. Disponible desde PHP 5.1.0.

''REQUEST_TIME_FLOAT''
La marca de tiempo del inicio de la solicitud, con microsegundos de precisión. Disponible desde PHP 5.4.0.

De esta manera, no necesita guardar una marca de tiempo al principio de su script. Simplemente puedes hacer:

<?php
// Do stuff
usleep(mt_rand(100, 10000));
// At the end of your script
$time = microtime(true) - $_SERVER["REQUEST_TIME_FLOAT"];
echo "Did stuff in $time seconds/n";
?>

Aquí, $time contendría el tiempo transcurrido desde el inicio del script en segundos, con una precisión de microsegundos (por ejemplo, 1.341 durante 1 segundo y 341 microsegundos)

Answer 7

Puedes usar microtime(true) con los siguientes modales:

Pon esto al inicio de tu archivo php:

//place this before any script you want to calculate time
$time_start = microtime(true);

// tu código de script va aquí

// do something

Pon esto al final de tu archivo php:

// Display Script End time
$time_end = microtime(true);
//dividing with 60 will give the execution time in minutes other wise seconds
$execution_time = ($time_end - $time_start)/60;
//execution time of the script
echo ''<b>Total Execution Time:</b> ''.$execution_time.'' Mins'';

Saldrá resultado en minutes .

Answer 8

Puedes usar la función de microtime para esto. De microtime :

microtime - Devuelve la marca de tiempo Unix actual con microsegundos

Si get_as_float se establece en TRUE , entonces microtime() devuelve un valor flotante, que representa la hora actual en segundos desde la época de Unix exacta al microsegundo más cercano.

Ejemplo de uso:

$start = microtime(true);
while (...) {
}
$time_elapsed_secs = microtime(true) - $start;

Answer 9

Si te gusta mostrar ese tiempo en segundos:

<?php
class debugTimer
{
private $startTime;
private $callsCounter;
function __construct()
{
$this->startTime = microtime(true);
$this->callsCounter = 0;
}
public function getTimer(): float
{
$timeEnd = microtime(true);
$time = $timeEnd - $this->startTime;
$this->callsCounter++;
return $time;
}
public function getCallsNumer(): int
{
return $this->callsCounter;
}
}
$timer = new debugTimer();
usleep(100);
echo ''<br />/n
''.$timer->getTimer(). '' seconds before call #''.$timer->getCallsNumer();
usleep(100);
echo ''<br />/n
''.$timer->getTimer(). '' seconds before call #''.$timer->getCallsNumer();

Answer 10

Tienes la idea correcta, excepto que hay una sincronización más precisa disponible con la función microtime .

Si lo que está dentro del bucle es rápido, es posible que el tiempo transcurrido aparente sea cero. Si es así, envuelva otro bucle alrededor del código y llámelo repetidamente. Asegúrese de dividir la diferencia por el número de iteraciones para obtener una vez por vez. He perfilado un código que requiere 10,000,000 iteraciones para obtener resultados de tiempo consistentes y confiables.

Answer 11

Ver microtime .

Answer 12

$start = microtime(true);
for ($i = 0; $i < 10000; ++$i) {
// do something
}
$total = microtime(true) - $start;
echo $total;