php - get tag name wordpress

¿Cómo puedo medir la velocidad del código escrito en PHP?

Question

¿Cómo puedo decir qué clase de muchos (que todos hacen el mismo trabajo) ejecutan más rápido? hay un software para medir eso?

Answer 1

Aquí hay una respuesta directa a su pregunta

hay un software para medir eso?

Sí hay. Me pregunto por qué nadie lo ha mencionado todavía. Aunque las respuestas sugeridas anteriormente parecen estar bien para un control rápido, pero no es escalable a largo plazo o para un proyecto más grande.

¿Por qué no utilizar una herramienta de Monitoreo del rendimiento de la aplicación (APM) que está construida exactamente para eso y mucho más? Echa un vistazo a NewRelic, AppDynamics, Ruxit (todos tienen versión gratuita) para controlar el tiempo de ejecución, el uso de los recursos, el rendimiento de cada aplicación al nivel del método.

Answer 2

He estado usando XHProf últimamente http://pecl.php.net/package/xhprof . Originalmente fue desarrollado por Facebook y viene con una interfaz web decente.

Answer 3

He hecho una clase de tiempo simple, tal vez sea útil para alguien:

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

}

Utilizar:

$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 4

Me gustaría compartir con ustedes una función propia que uso para medir la velocidad de cualquier función existente de hasta 10 argumentos:

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;

}

Ejemplo

function do_stuff($arg1='''', $arg2=''''){
    return $arg1.'' ''.$arg2;
}

fdump(''do_stuff'',array(''hello'', ''world''));

Devoluciones

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

Answer 5

Para cosas rápidas, hago esto (en PHP):

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

También puede usar un generador de perfiles como Xdebug .

Answer 6

Puede usar elementos básicos como almacenar marcas de tiempo o microtime () antes y después de una operación para calcular el tiempo necesario. Eso es fácil de hacer, pero no muy preciso. Tal vez una mejor solución es Xdebug , nunca he trabajado con ella, pero parece ser el depurador / generador de perfiles de PHP más conocido que puedo encontrar.

Answer 7

Si desea probar rápidamente el rendimiento de un marco, puede ponerlo en el archivo index.php

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

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

Cada vez obtendrá tiempo de ejecución en milisegundos . Porque microsegundos no es demasiado útil para probar un caso de marco.

Answer 8

Si es algo que se puede probar fuera del contexto web, solo uso el comando de time Unix.

Answer 9

Usted tiene (al menos) dos soluciones:

El bastante "ingenuo" está usando microtime (verdadero) antes y después de una porción de código, para saber cuánto tiempo ha pasado durante su ejecución; otras respuestas dicen eso y ya dieron ejemplos, así que no voy a decir mucho más.

Esta es una buena solución si desea comparar un par de instrucciones; como comparar dos tipos de funciones, por ejemplo, es mejor si se realiza miles de veces, para asegurarse de promediar cualquier "elemento perturbador".

Algo como esto, entonces, si quieres saber cuánto tiempo lleva serializar una matriz:

$before = microtime(true);

for ($i=0 ; $i<100000 ; $i++) {
    serialize($list);
}

$after = microtime(true);
echo ($after-$before)/$i . " sec/serialize/n";

No es perfecto, pero es útil, y no toma mucho tiempo configurarlo.

La otra solución, que funciona bastante bien si quieres identificar qué función ocupa mucho tiempo en una secuencia de comandos completa, es usar:

• La extensión Xdebug , para generar datos de creación de perfiles para la secuencia de comandos
• Software que lee los datos de creación de perfiles y le presenta algo legible. Sé que tres de ellos:
  • Webgrind ; interfaz web ; debería funcionar en cualquier servidor Apache + PHP
  • WinCacheGrind ; solo en windows
  • KCacheGrind ; probablemente solo Linux y Linux; Esa es la que yo prefiero, por cierto

Para obtener archivos de creación de perfiles, debe instalar y configurar Xdebug; Eche un vistazo a la página Perfiles de scripts de PHP de la documentación.

Lo que generalmente hago es no habilitar el generador de perfiles de manera predeterminada (genera archivos bastante grandes y ralentiza el proceso) , pero utilizo la posibilidad de enviar un parámetro llamado XDEBUG_PROFILE como datos GET, para activar el perfil solo para la página que necesito.
La parte relacionada con el perfil de mi php.ini se ve así:

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

(Lea la documentación para más información)

Esta captura de pantalla es de un programa C ++ en KcacheGrind: http://kcachegrind.sourceforge.net/html/pics/KcgShot3Large.gif http://kcachegrind.sourceforge.net/html/pics/KcgShot3Large.gif
Obtendrá exactamente el mismo tipo de cosas con scripts PHP ;-)
(Con KCacheGrind, quiero decir, WinCacheGrind no es tan bueno como KCacheGrind ...)

Esto le permite obtener una buena visión de lo que toma tiempo en su aplicación y, a veces, definitivamente ayuda a localizar la función que está desacelerando todo ^^

Tenga en cuenta que Xdebug cuenta el tiempo de CPU gastado por PHP; cuando PHP está esperando una respuesta de una Base de Datos (por ejemplo), no está funcionando; solo esperando. ¡Entonces Xdebug pensará que la solicitud DB no toma mucho tiempo!
Esto se debe perfilar en el servidor SQL, no en PHP, entonces ...

Espero que esto sea útil :-)
Que te diviertas !

Answer 10

Zend Studio ha incorporado soporte para crear perfiles utilizando XDebug o ZendDebugger. Perfilará su código, diciéndole exactamente cuánto tiempo tomó cada función. Es una herramienta fantástica para descubrir dónde están los cuellos de botella.