Forma precisa de medir los tiempos de ejecución de scripts php

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

Puede usar la microtimefunción para esto. De la documentación :

microtime - Devuelve la marca de tiempo actual de Unix con microsegundos

---

Si get_as_floatse establece en TRUE, entonces microtime()devuelve un flotante, que representa el tiempo actual en segundos desde la época de Unix con precisión al microsegundo más cercano.

Ejemplo de uso:

$start = microtime(true);
while (...) {

}
$time_elapsed_secs = microtime(true) - $start;

Se puede usar microtime(true)con los siguientes modales:

Ponga esto al comienzo de su archivo php:

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

// su 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';

Producirá el resultado minutes.

Puede usar REQUEST_TIMEdesde la $_SERVERmatriz superglobal. De la documentación :

REQUEST_TIME
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 precisión de microsegundos . (Disponible desde PHP 5.4.0.)

De esta manera, no necesita guardar una marca de tiempo al comienzo de su secuencia de comandos. 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í, $timecontendría el tiempo transcurrido desde el inicio de la secuencia de comandos en segundos, con precisión de microsegundos (por ejemplo, 1.341durante 1 segundo y 341 microsegundos)

Más información:

Documentación de PHP : $_SERVERvariables y microtimefunción

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

Que en el comienzo de su guión, después de <?phpescribirinclude 'loadtime.php'; $loadtime=new loadTime();

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

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

Ver microtime () .

Aquí hay una función que multiplica la ejecución de cualquier pieza 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

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

Tiene la idea correcta, excepto que está disponible una sincronización más precisa 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 entre el número de iteraciones para obtener una vez por vez. He perfilado un código que requería 10,000,000 iteraciones para obtener resultados de tiempo consistentes y confiables.

Pensé en compartir la función que armé. Esperemos que pueda ahorrarle tiempo.

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

Hará todos los cálculos por usted durante cuánto tiempo ha pasado desde el inicio del guión y en cada paso. Formatea toda la salida con 3 decimales de precisión. (Abajo a milisegundos)

Una vez que lo copie en la parte superior de su secuencia de comandos, todo lo que debe hacer es colocar las llamadas a la función recordTime después de cada pieza que desee cronometrar.

Copie esto en la parte superior de su 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 resultados como este:

//     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!

Aquí hay un método muy simple y breve

<?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
?>

si desea 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();

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

Aquí está mi script para medir el tiempo promedio

<?php

$times = [];
$nbrOfLoops = 4;
for ($i = 0; $i < $nbrOfLoops; ++$i) {
    $start = microtime(true);
    sleep(1);
    $times[] = microtime(true) - $start;
}

echo 'Average: ' . (array_sum($times) / count($times)) . 'seconds';

Puede encontrar el tiempo de ejecución en segundo con una sola función.

// ampersand is important thing here
function microSec( & $ms ) {
    if (\floatval( $ms ) == 0) {
        $ms = microtime( true );
    }
    else {
        $originalMs = $ms;
        $ms = 0;
        return microtime( true ) - $originalMs;
    }
}

// you don't have to define $ms variable. just function needs
// it to calculate the difference.
microSec($ms);
sleep(10);
echo microSec($ms) . " seconds"; // 10 seconds

for( $i = 0; $i < 10; $i++) {
    // you can use same variable everytime without assign a value
    microSec($ms);
    sleep(1);
    echo microSec($ms) . " seconds"; // 1 second
}

for( $i = 0; $i < 10; $i++) {
    // also you can use temp or useless variables
    microSec($xyzabc);
    sleep(1);
    echo microSec($xyzabc) . " seconds"; // 1 second
}