¿Cómo puedo decir qué clase de muchas (que hacen el mismo trabajo) se ejecutan más rápido? ¿Existe un software para medir eso?
fuente
¿Cómo puedo decir qué clase de muchas (que hacen el mismo trabajo) se ejecutan más rápido? ¿Existe un software para medir eso?
Tienes (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 dijeron eso y ya dieron ejemplos, así que no diré 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 hace miles de veces, para asegurarse de que se promedie cualquier "elemento perturbador".
Algo como esto, entonces, si desea 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 lleva mucho tiempo configurarlo.
La otra solución, que funciona bastante bien si desea identificar qué función lleva mucho tiempo en un script completo, es usar:
Para obtener archivos de creación de perfiles, debe instalar y configurar Xdebug; eche un vistazo a la página de creación de perfiles de scripts PHP de la documentación.
Lo que generalmente hago no es habilitar el generador de perfiles de forma predeterminada (genera archivos bastante grandes y ralentiza las cosas) , sino que uso la posibilidad de enviar un parámetro llamado XDEBUG_PROFILE
datos GET, para activar el perfil solo para la página que necesito.
La parte relacionada con la creación de perfiles 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: (fuente: sourceforge.net ) 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 vista de lo que lleva tiempo en su aplicación y, a veces, definitivamente ayuda a localizar la función que está ralentizando todo ^^
Tenga en cuenta que Xdebug cuenta el tiempo de CPU empleado 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 lleva mucho tiempo!
Esto debe perfilarse en el servidor SQL, no PHP, así que ...
Espero que esto sea útil :-) ¡
Diviértete!
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 utilizar un generador de perfiles como http://xdebug.org/ .
Hice una clase de cronometraje 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
echo
, no$echo
Actualización 2020
Han pasado muchos años desde la última vez que respondí a estas preguntas, así que pensé que esto merece una actualización sobre el panorama de APM.
Aquí hay una respuesta directa a su pregunta.
¿Existe 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 una verificación rápida, no son escalables a largo plazo o para un proyecto más grande.
¿Por qué no utilizar una herramienta de supervisión del rendimiento de las aplicaciones (APM) que está diseñada exactamente para eso y mucho más? Consulte NewRelic, AppDynamics, Ruxit (todos tienen versión gratuita) para monitorear el tiempo de ejecución, el uso de recursos y el rendimiento de cada aplicación al nivel del método.
Si desea probar rápidamente el rendimiento de un marco, puede colocar el archivo index.php
//at beginning
$milliseconds = round(microtime(true) * 1000);
//and at the end
echo round(microtime(true) * 1000) - $milliseconds;
Cada vez obtendrá el tiempo de ejecución en milisegundos . Porque los microsegundos no son demasiado útiles para probar un caso marco.
He estado usando XHProf últimamente http://pecl.php.net/package/xhprof . Fue desarrollado originalmente por Facebook y viene con una interfaz web decente.
Me gustaría compartir con ustedes una función hecha por mí mismo que uso para medir la velocidad de cualquier función existente 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"
}
Si es algo que se puede probar fuera del contexto web, solo uso el time
comando Unix .
Zend Studio ha incorporado soporte para la creación de perfiles utilizando XDebug o ZendDebugger. Perfilará su código, indicándole exactamente cuánto tiempo tomó cada función. Es una herramienta fantástica para averiguar dónde están sus cuellos de botella.
Puede usar cosas básicas 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 sea Xdebug , nunca he trabajado con él, pero parece ser el depurador / perfilador de PHP más conocido que puedo encontrar.