PHP Benchmark nace como un sitio en el cual su único objetivo es demostrar que no todos los procesos similares de PHP funcionan a la misma velocidad, podeis visitar la página, pero para aquellos que no les gusta el inglés dejo las partes que me parecieron mas curiosas:



+ 105 %   comillas simples (') en una string vacia: $tmp[] = ''';
+ 102 %   comillas dobles (") en una string vacia: $tmp[] = "";
+ 100 %   simples ('). 20 bytes de texto: $tmp[] = 'aaaaaaaaaaaaaaaaaaaa';
+ 103 %   dobles ("). 20 bytes de texto: $tmp[] = "aaaaaaaaaaaaaaaaaaaa";
+ 102 %   simples ('). 20 bytes de teto y 3 $: $tmp[] = 'aa $ aaaa $ aaaa $ a';
+ 106 %   dobles ("). 20 bytes de teto y 3 $: $tmp[] = "aa $ aaaa $ aaaa $ a";
+ 100 %   dobles ("). . 20 bytes de teto y 3 \$: $tmp[] = 'aa \$ aaaa \$ aaaa \$ a';

Conclusión: en este caso podemos llegar a la conclusión de que ambas formas no suponen una gran diferencia de velocidades y que con las comillas dobles, escapar los carácteres como $ (\$) supone un ahorro de tiempo, mínimo eso si.


+ 100 %   foreach($aHash as $val);
+ 657 %   while(list($val)) = each($aHash);
+ 119 %   foreach($aHash as $key => $val);
+ 688 %   while(list($key,$val)) = each($aHash));
+ 238 %   foreach($aHash as $key => $val) $tmp[] = $aHash[$key];
+ 757 %   while(list($key)) = each($aHash)) $tmp[] = $aHash[$key];
+ 300 %   Get Key-/value-array: foreach($aHash as $key[]=>$val[]);
+ 329 %   Get Key-/value-array: array_keys() / array_values()
+ 381 %   $key = array_keys($aHash);  $size = sizeOf($key); for($i=0; $i < $size; $i++) $tmp[] = $aHash[$key[$i]];

Conclusión: La conclusión mas obvia que podemos sacar es que foreach() es mas rapido que while() y
for()


acabo con este que me pareció muy muy curioso:


El test se orienta a, si el rendimiento cambia al calcular el tamaño de una variable antes del for o en el momento que declaramos el for.

Ejemplos:
antes del for: "for ($i=0; $i<$tamaño; $i++)"
en el for: "for ($i=0; $i<sizeOf($x); $i++)"

+ 100 %      Antes del for con count()
+ 50058 %   En el for con count()
+ 100 %      Antes del for con sizeof()
+ 50421 %   En el for con sizeof()

Conclusión: este es quizá el ejemplo mas claro a la hora de programar nuestras aplicaciones, hemos de tener muy en cuenta que el tamaño deveriamos calcularlo antes de declarar el for() para así agilizar sustancialmente nuestra aplicación.

Sin mas os animos a visitar la página del autor: http://www.phpbench.com/

Entrada original: My blog: Syntax Error

jajaja pues con funciones de php por supuesto xD

si vas a la web del creador dice:


y si le das a "view code" de cualquiera de sus codes publicados puedes ver como la usa:

<?php
 
// Test Source
function Test4_1() {
    global $x;
 
    /* The Test */
    $t = microtime(true);
    $size = count($x);
    $i = 0;
    while($i < 1000) {
        $alias = $aSingleDimArray[$i];
        ++$i;
    }
 
    return (microtime(true) - $t);
}
 
?>
 

Sería bueno comprarar la ejecución de un pequeño script con un objeto clase orientado al POO y otro con arrays multidimensionales xD

más que bueno divertido xd, debe ser muy bestia la diferencia de uso de procesador que se usa en POO y arrays multidimensionales, en este último caso sería mucho mayor.... xD

P.D: Buen post, me documentaré cuando tenga tiempo de este tema ya que me interesa

Es bueno optimizar el codigo o al menos intentarlo. Optimizar el codigo solo funcionara para conocer el lado de consumo del codigo como tal.. esto es totalmente independiente de las consultas a la base de datos (Sobretodo por lo que les expuse anteriormente, donde los datos se guardan en un buffer de la libreria que trabaja con el motor de DB). Es un proceso un poco extenso si te dedicas al tema, pero como es algo que me encanta hacer    suelo depurar primero base de datos con profiling, luego al codigo fuente con Benchmark 

fede_cp si quieres obtener el rendimiento de un programa entero como dices, debes crear un archivo que funcione de 'main' o principal y dentro de este inicializar el objeto Benchmark, y ir llamando las funciones de modulos por modulos el caso es que cuando termines de llamar funciones de modulos, finalizar el objeto Benchmark he imprimir el resultado en pantalla o enviarlo a un archivo