clase cronometro, algo parecido a un timer

[loluchis]

Esta es la clase:

Código PHP:

  class Cronometro
{
    static private $inicio;
    static private $fin;
    
    static public function iniciar()
    {
    static::$inicio = microtime(true);
    }
    
    static public function finalizar()
    {
    static::$fin = microtime(true);
    }
    
    static public function diferencia()
    {
    $dif = static::$fin - static::$inicio;
    $dif = number_format($dif, 4, '.', '');
    
    return $dif;
    }
} 
   

me mosquea lo siguiente:
nada mas empezar mi aplicacion, en el index, incluso antes de iniciar la sesion o definir el base path, ejecuto el cronometro, hago Cronometro::inicar();, y solo justo antes de cerrar el footer de mi web hago Cronometro::finalizar();, muy bien, ahora quiero saber la diferencia de esos tiempos para comprobar lo pesada que pueda llegar a ser mi pagina, y la verdad es que no entiendo mucho de tiempos de carga optimos, diferentes navegadores me arrojan los siguientes resultados:

la pagina se genera en:
opera 1318893713.5653
chrome 1318893711.6973
firefox 1318893923.1052

salen en el siguiente formato como se puede ver en el codigo:

Código:

$dif = number_format($dif, 4, '.', '');

lo mas seguro es que YO no sepa formatear bien esa salida...

estos tiempos son correctos o bajos o altos? gracias por la ayuda

[GatorV]

Es demasiado tiempo, pero lo que puedes hacer para formatear es usar: number_format($dif, 2, '.', ',');

Saludos.

[loluchis]

sabes alguna refencia en internet para mirar tiempos optimos de carga? es raro porque no toco la base de datos, solo ejecuto la aplicacion, se registra un autoload, se registra un controlador de errores y excepciones, genero a proposito una excepcion y se carga una vista con el error mediante require_once, puede deberse al abuso de objetos estaticos?

[loluchis]

Pues creo que lo he solucionado, he visto un script por ahi de como sacar el tiempo lo he adaptado un poco y me salen tiempos mas claros:

Código PHP:

  class Cronometro
{
 
    static private $inicio;
    static private $fin;
 
    static public function iniciar()
    {
    $starttime = explode(' ', microtime());
    static::$inicio = $starttime[1] + $starttime[0];
    }
 
    static public function finalizar()
    {
    $mtime = explode(' ', microtime());
    static::$fin = $mtime[0] + $mtime[1] - static::$inicio;
    }
 
    static public function diferencia()
    {
    return static::$fin;
    }
 
} 
   

0.00052499771118164, creo que eso es mas normal, verdad? saludos gracias

[Ronruby]

Iniciado por loluchis

Pues creo que lo he solucionado, he visto un script por ahi de como sacar el tiempo lo he adaptado un poco y me salen tiempos mas claros:

Código PHP:

  class Cronometro
{
 
    static private $inicio;
    static private $fin;
 
    static public function iniciar()
    {
    $starttime = explode(' ', microtime());
    static::$inicio = $starttime[1] + $starttime[0];
    }
 
    static public function finalizar()
    {
    $mtime = explode(' ', microtime());
    static::$fin = $mtime[0] + $mtime[1] - static::$inicio;
    }
 
    static public function diferencia()
    {
    return static::$fin;
    }
 
} 
   

0.00052499771118164, creo que eso es mas normal, verdad? saludos gracias

Es imposible decirte cual es el tiempo "optimo" en que corre una aplicacion. Los factores que influyen son bastantes asi tambien como importa muchisimo que acciones realices.

[Webstudio]

Cómo estás?
mirá, te muestro un ejemplo de una clase que uso yo, para este tipo de mediciones. Le puse "Timer" y lo cierto es que me resulta bastante útil de vez en cuando.

Código PHP:

  <?php
/**
 * Class that handles the timer marks
 * Useful for time comparisons and memory usage statistics
 *
 * @author Pablo Rigazzi <[email protected]>
 */
class Timer
{
    /**
     * Set of marks.
     *
     * @var array $_marks
     * @private
     * @static
     */
    static private $_marks = array();
 
    /**
     * Adds a mark to the queue.
     *
     * @param string $name Name of the mark.
     *
     * @return void
     * @public
     * @static
     */
    static public function mark($name) {
        self::$_marks[] = array(
                'name' => $name,
                'mark' => microtime(true),
                'muse' => memory_get_usage()
                );
    }
 
    /**
     * Prints object information.
     *
     * @return string
     * @public
     * @static
     */
    static public function toString() {
        $result = array();
        for($i = 1; $i < count(self::$_marks); $i++) {
            $tdelta    = self::$_marks[$i]['mark'] - self::$_marks[$i-1]['mark'];
            $mdelta    = self::$_marks[$i]['muse'] - self::$_marks[$i-1]['muse'];
 
 
            $result[]  = sprintf('%s - %s: %.5f secs (Mem: %d Kb)',
                            self::$_marks[$i-1]['name'],
                            self::$_marks[$i]['name'],
                            $tdelta,
                            $mdelta / 1024);
        }
        --$i;
        return "<!--\nTimer Information:" . PHP_EOL .
                implode("\n", $result) . PHP_EOL .
                "Total time  / memory tracked : " . 
                sprintf('%.5f secs (Mem: %d Kb)',
                        self::$_marks[$i]['mark'] - self::$_marks[0]['mark'],
                        (self::$_marks[$i]['muse'] - self::$_marks[0]['muse']) / 1024) . PHP_EOL .
                "Peak Memory Usage : " . memory_get_peak_usage(true) / 1024 . " Kb" . PHP_EOL .
       "-->";
    }
}   

El método de uso es mucho muy sencillo. A lo largo de tu código, simplemente vas haciendo "marcas" con tu timer, como si estuvieras marcando una vuelta en una carrera o dejando "tags" en el ciclo de ejecución de tu sitio:

Código PHP:

  Timer::mark('inicio');
Hago_algo();
Timer::mark('después de hacer algo');
 
// Sigue tu código y al finalizar, lo que hacés es : 
echo Timer::toString(); 
   

Y listo, el método toString() devuelve la información de todos los puntos que marcaste, la diferencia de tiempo entre los distintos puntos, y el consumo de memoria en cada uno de los puntos, más la información de la máxima memoria que utilizó tu script en su ejecución.

Espero que te resulte útil.