Rendimiento de PHP en un proceso complejo

[goc00]

Saludos:

Mi consulta va orientada hacia el rendimiento que tiene PHP sobre un proceso complejo y algo extenso, me explico:

Tengo un módulo de administración, que deberá actualizar más de 10.000 registros (es un concurso de inversiones, así que debe calcular la rentabilidad todos los días de los concursantes sobre los movimientos que él haya realizado), el punto es que son muchos los registros afectados, por lo tanto surgió mi duda inmediatamente si PHP puede llegar a realizar esto sin que se cuelgue.

Mi otra opción, más complicada, es que procedimientos almacenados en mi BD hagan dicha tarea.

¿Qué me recomiendan ustedes?, PHP se la puede o tendré que estrujar la mente para crear procedimientos almacenados (entiéndase triggers, procedures, etc.) y darle la responsabilidad a la máquina servidor.

[AlvaroG]

PHP puede manejarlo si el servidor lo soporta, hay que considerar eso también.
Ante la duda de PHP o procedimientos en la base de datos, yo me inclino hacia los procedimientos en la base de datos. Creo que probablemente tengan un mejor rendimiento.

En cualquiera de los dos casos, lo que necesitás son servidores bien configurados en máqinas que soporten la carga. PHP aguantará sin problemas bajo esas condiciones.


saludos.

[GatorV]

Estoy de acuerdo con alvlin, todo depende de tu maquina y que tan optimizado tengas tu codigo.

Me inclino tambien hacia que sean procesos en la base de datos, asi garantizas consistencia al dejar que la misma base de datos ejecute su procedimiento.

Saludos.

[goc00]

Muchas gracias estimados, definitivamente parece que los procedimientos son la mejor alternativa, habrá que comenzar a idear la solución en base a esa opción.

[goc00]

Me surgió una nueva duda. Si yo llamo a un procedimiento almacenado desde PHP, ¿estoy sujeto a la restricción de tiempo de ejecución de script de PHP? (porque de ser así no tendría mucho sentido crear procedimientos almacenados).

[GatorV]

puedes probar con:

Código PHP:

  set_time_limit(0);  
   

En tu script, pero ten en cuenta que tienes que tener un super control de tu script para evitar desbordar la memoria (cosa que puede pasar).

Saludos.

[goc00]

Iniciado por GatorV

puedes probar con:

Código PHP:

  set_time_limit(0);  
   

En tu script, pero ten en cuenta que tienes que tener un super control de tu script para evitar desbordar la memoria (cosa que puede pasar).

Saludos.

Lo pondré al inicio de mi página PHP entonces, aunque la realidad es que no me ha suscitado el problema de que el script se cancele por superar el tiempo de ejecución, pero como sé lo que estará en la base de datos, en algún momento demandará su buen tiempo en procesar tanto registro e información (es un hecho que no puedo descartar, porque estoy seguro que sucederá). Digamos que "estoy poniéndome el parche antes de la herida".

Claro, eso siempre lo trato de mantener controlado (aunque hace poco hice algo en VB6 y no logré encapsular el maravilloso problema... desbordamiento. Me di cuenta que no sólo es el tema del algoritmo a la hora de programar, el tipo de datos es fundamental también).

Con respecto a PHP, este proceso que ya me está dando pesadillas por lo que podría suceder en un futuro no muy lejano y el tema de control de memoria; tu sugerencia o precaución va en relación a despejar espacios de memoria (por ejemplo, utilizar correctamente funciones como mysql_free_result($soyUnRS) y cosas por el estilo, además obviamente de tratar de optimizar al máximo las consultas y crear si o si procedimientos almacenados)... ¿estoy pensando bien la solución?.

[GatorV]

Asi es, tambien como si estas ocupando variables, desalojarlas lo mas pronto posible:
$unavar = null;
Asi te evitas estar creando variables y comiendo la memoria del proceso.

[wrkjmg]

No me parece muy buena idea poner el set_time_limit a 0.
Mira que si algo falla en tu codigo y entras en un bucle recursivo se te quedara colgao el server indefinidamente.

Cuando se sobrepasa el limite tanto de memoria, como de tiempo etc, PHP te da un mensaje advirtiendote, llegados a este punto puedes aumentar un poco mas el limite de tiempo , o estrujarte los sesos para conseguir codigo con mejor rendimiento, que ya se esta perdiendo este arte, hoy dia se programa a lo bruto, codigo escrito tal cual te viene a la cabeza.

Lo de cargar la tarea al server de la base de datos, tampoco me parece muy buena idea. Mejor que trabaje el server que se puso para que curre, y deja que el server de la base de datos se dedique a controlar los datos. Eso si , si llega un punto en que el server de PHP ya no te da a basto, bueno, ... hay que buscarse la vida como sea, que curre el server de mysql.

Esto es solo mi humilde opinion. Tampoco soy ningun experto.

A veces combiene escribir mas codigo en pro del rendimiento, por ejemplo:
Es mas rapido para el server hacer
$variable++;
$variable++;
$variable++;

que hacer $variable+= 3;

Aunque hoy dia los buenos compiladores, no se si sera el caso de PHP, sustituyen un $variable+=2; por $variable++; $variable++; de forma automatica.

[goc00]

Toda opinión es válida estimado, no dude en escribirla porque puede servir para ver puntos que uno no alcanza a percibir o se quedan en el tintero.

Lo sé, es un poco arriesgada dicha función, pero mientras ideo un conjunto de stored procedures (que sería dejar que el servidor ejecute las tareas, "dejando de lado" el flujo cliente-servidor, que como ya sabemos está muy restringido a una serie de factores) podría ser una opción viable si me aseguro que no habrá problemas de ejecución.

[GatorV]

Tienes alguna fuente para decir que:

Código PHP:

  $variable++;
$variable++;
$variable++;  
   

Es mas rapido que:

Código PHP:

  $variable+= 3;  
   

[goc00]

Buen punto, no había tomado atención a lo último que planteó wrkjmg. Hasta donde yo sé:

Código PHP:

  $variable += 3;  
   

Utiliza el operador += que se asemeja a un:

Código PHP:

  $variable = $variable + 3;  
   

Cosa que sería mucho más rápido y óptimo que:

Código PHP:

  $variable++;
$variable++;
$variable++;  
   

[GatorV]

Si, pero el comenta que es mas rapido de la otra forma, o entendi mal, jaja.

[goc00]

Iniciado por GatorV

Si, pero el comenta que es mas rapido de la otra forma, o entendi mal, jaja.

Claro, eso es lo que está diciendo él, por eso sería bueno que diera una base de porque dice aquello.

[wrkjmg]

Viereis ,me baso en que el código que escribís en realidad es compilado y convertido en instrucciones de ensamblador, que en realidad son las únicas que entiende el microprocesador.

El juego de instrucciones del microprocesador es distinto de PHP, una instrucción de suma en ensamblador podría ser
'ADD variable,3'
Esta instrucción consume un numero de pasos(ciclos) que tiene que dar el Microprocesador para realizar la operación, podrían ser 5 ciclos (en los pentium de antes eran 5, creo recordar, en los pentium 4 de ahora no lo se).
pero el micro incluye otra instrucción llamada
'INC variable'
que incrementa en 1 la variable, y esta operación solo le cuesta 1 ciclo, por lo que hacer variable+3 = 5 ciclos del micro y hacer inc variable x 3 = 3 ciclos del micro. Es mas rápido para el micro la segunda opción.

El motor de PHP lo que hace es convertir nuestro código en estas instrucciones del micro, por eso PHP tiene la opción de variable++, que es igual que la instrucción INC variable de ensamblador.
Si no para que se iban a molestar en incluir la opción de variable++, cuando cuesta casi lo mismo que escribir variable += 1.

Además es mas rápido para el motor de PHP, porque sabe que variable++ es igual a INC variable sin necesidad de comprobar nada mas, pero variable+=3 , primero tiene que mirar si el parámetro a sumar (que en este caso es 3) es un numero , o un caracter , o es un numero de coma flotante...etc, porque la suma no se hace igual si es un numero entero que un flotante ó un carácter, porque podría ser una letra en lugar de un numero ($variable+='a' esto PHP lo acepta). Todo el proceso que hace PHP para comprobar esto es tiempo de proceso del micro.

Os puedo asegurar que a PHP le cuesta mas procesar $variable+=1 que $variable++. Muchos compiladores optimizan el código y convierte automaticamente un $variable+=1 en un $variable++, porque saben que el resultado es el mismo pero $variable++ es mas rápido. En el caso de PHP no se si sera así.

Por el mismo motivo, aunque en PHP hay varias funciones que realizan la misma tarea, según para que sea, te recomiendan que uses unas en lugar de otras, porque una es mas rápida que otra. Leeros del manual oficial de PHP ttp://es2.php.net/manual/es/function.strstr.php es la explicacion de la función strstr() vereis como recomienda usar strpos() segun que caso.

En fin, espero haberme explicado bien, es difícil ya que pocos se acuerdan ya del ensamblador y el C original (sin ++), que eran lenguajes mas directos al juego de instrucciones del micro. Me estoy haciendo viejo

[GatorV]

Mmm perdon pero creo estas mal, si pruebas este codigo, veras que el operador += esta mas optimizado que el ++.

Salida:

Código:

Test1:
Haciendo 1000 ciclos; Tiempo inicial: 1180534724.22
Fin; 1180534724.22
Diferencia: 0.00440311431885




Test2:
Haciendo 1000 ciclos; Tiempo inicial: 1180534724.22
Fin; 1180534724.23
Diferencia: 0.00407600402832




Test3:
Haciendo 1000 ciclos; Tiempo inicial: 1180534724.23
Fin; 1180534724.23
Diferencia: 0.00200486183167

Codigo:

Código PHP:

  <?php
header("Content-type: text/plain");
function test1() {
    $myvar = 0;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
}

function test2() {
    $myvar = 0;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
    $myvar++;
}

function test3() {
    $myvar = 0;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
    $myvar += 10;
}

echo "Test1:\n";
$start = microtime(true);
echo "Haciendo 1000 ciclos; Tiempo inicial: " . $start . "\n"; 
for( $i = 0; $i < 1000; $i++ ) {
    test1();
}
$fin = microtime(true);
$diff = $fin - $start;
echo "Fin; " . $fin . "\n";
echo "Diferencia: " . $diff . "\n";
echo "\n\n\n\n";

echo "Test2:\n";
$start = microtime(true);
echo "Haciendo 1000 ciclos; Tiempo inicial: " . $start . "\n"; 
for( $i = 0; $i < 1000; $i++ ) {
    test2();
}
$fin = microtime(true);
$diff = $fin - $start;
echo "Fin; " . $fin . "\n";
echo "Diferencia: " . $diff . "\n";
echo "\n\n\n\n";

echo "Test3:\n";
$start = microtime(true);
echo "Haciendo 1000 ciclos; Tiempo inicial: " . $start . "\n"; 
for( $i = 0; $i < 1000; $i++ ) {
    test3();
}
$fin = microtime(true);
$diff = $fin - $start;
echo "Fin; " . $fin . "\n";
echo "Diferencia: " . $diff . "\n";
echo "\n\n\n\n";
?>   

[nicolaspar]

Muy interesante el comentario de bajo nivel que hace wrkjmg, aunque las papas de la prueba de GatorV diga que no es correcto.

Un solo aporte, trata si usas la db para el proceso, de NO usar cursores, whiles y demás métodos que matan la db.
Si necesitas recurrir a éstos es mejor usar en este caso trabajar con php que hará el proceso más rápido.
Además, generalmente los hosts le dedican mucho menos recursos a la db, es un dato para tener en cuenta.


Saludos

[wrkjmg]

Ya he comentado que el motor PHP no se como va.
Es muy probable que ya este optimizado para esto, hoy dia todos lo estan.

Lo de $variable++ lo he puesto como ejemplo, en C++ de los pentium de antes si que era asi.

De todas formas GatorV tu prueba tiene poca consistencia, ya me curro una prueba y asi averiguamos si php esta ó no optimizado para este asunto, que imagino que si, pues esto ya es bastante antiguo (1996 o asi).

GatorV, tienes que conseguir que la variable tenga el mismo valor al finalizar cada prueba, queiro decir que despues de los 1000 ciclos con $myvar++ myvar tenga el mismo valor que despues de hacerlo con myvar +=. No se cual es el valor porque paso de contar el numero de lineas que has puesto de $myvar++.
La cuestion es que quites el $myvar=0 de la funcion y lo pongas a 0 antes del bucle for y si cuando salga del bucle myvar=20000 por ejem. en el bucle de $myvar+= tambien tiene que quedar myvar con 20000. Y en lugar de hacer myvar+=10 haz myvar+=2, porque elequivalente de myvar+=10 en myvar++ seria de 10 myvar++, entonces si que es mas lento claro. La cuestion es comparar myvar += 2 con myvar++ x2.

[GatorV]

Ok, muy de acuerdo, modifique para que cuente del 0 al 100 en 1000 ciclos uno con puros ++, y otros con =+, estos son los resultados:

Código:

Test1:
Haciendo 10000 ciclos; Contando de 0 a 100; Tiempo inicial: 1180543884.28
Fin; 1180543884.29
Diferencia: 0.00607705116272




Test2:
Haciendo 10000 ciclos; Contando de 0 a 100; Tiempo inicial: 1180543884.29
Fin; 1180543884.29
Diferencia: 0.0016770362854

[GatorV]

Curioso el rendimiento de este script:

Código:

Test1:
Haciendo 100000 ciclos; Incrementando con ++; Tiempo inicial: 1180544284.69
Fin; 1180544284.71
Diferencia: 0.0236029624939




Test2:
Haciendo 100000 ciclos; Incrementando con += $i; Tiempo inicial: 1180544284.71
Fin; 1180544284.71
Diferencia: 0.00231003761292

El script:

Código PHP:

  echo "Test1:\n";
$start = microtime(true);
echo "Haciendo 100000 ciclos; Incrementando con ++; Tiempo inicial: " . $start . "\n"; 
$var = 0;
for( $i = 0; $i < 100000; $i++ ) {
    $var++;
}
$fin = microtime(true);
$diff = $fin - $start;
echo "Fin; " . $fin . "\n";
echo "Diferencia: " . $diff . "\n";
echo "\n\n\n\n";

echo "Test2:\n";
$start = microtime(true);
echo "Haciendo 100000 ciclos; Incrementando con += \$i; Tiempo inicial: " . $start . "\n"; 
$var = 0;
for( $i = 0; $i < 100000; $i+= 10 ) {
    $var += $i;
}
$fin = microtime(true);
$diff = $fin - $start;
echo "Fin; " . $fin . "\n";
echo "Diferencia: " . $diff . "\n";
echo "\n\n\n\n";  
   

[wrkjmg]

GatorV este seria un codigo mas apropiado para ver la diferencia de tiempo entre las dos:

Código PHP:

  <?php 
echo "Test1:<br/>\n"; 
$start = microtime(true); 
echo "Haciendo 100000 ciclos; Incrementando con ++; Tiempo inicial: " . $start . "<br/>\n";  
$var1 = 0; 
for( $i = 0; $i < 100000; $i++ ) { 
    $var1++; 
    $var1++; 
} 
$fin = microtime(true); 
$diff1 = $fin - $start; 
echo "Fin; " . $fin . "<br/>\n"; 
echo "Diferencia: " . $diff1 . "<br/>\n"; 
echo "<br/>\n<br/>\n<br/>\n<br/>\n"; 
 
echo "Test2:<br/>\n"; 
$start = microtime(true); 
echo "Haciendo 100000 ciclos; Incrementando con += \$i; Tiempo inicial: " . $start . "<br/>\n";  
$var2 = 0; 
for( $i = 0; $i < 100000; $i++ ) { 
    $var2 += 2; 
} 
$fin = microtime(true); 
$diff2 = $fin - $start; 
echo "Fin; " . $fin . "<br/>\n"; 
echo "Diferencia: " . $diff2 . "<br/>\n"; 
echo "<br/>\n<br/>\n<br/>\n<br/>\n";   
 
echo $var1." = ".$var2."<br/>\n"; 
echo "Con ++: ".$diff1."<br/>\n"; 
echo "Con +=: ".$diff2."<br/>\n"; 
?>   

Lo curioso es el resultado que me da:

Test1:
Haciendo 100000 ciclos; Incrementando con ++; Tiempo inicial: 0.91400600 1180549970
Fin; 0.55141800 1180549971
Diferencia: -0.362588




Test2:
Haciendo 100000 ciclos; Incrementando con += $i; Tiempo inicial: 0.55203000 1180549971
Fin; 0.05727700 1180549972
Diferencia: -0.494753




200000 = 200000
Con ++: -0.362588
Con +=: -0.494753

Buff , las dos instrucciones retrasan el tiempo, acabamos de encontrara el algoritmo para viajar atras en el tiempo

No se porque sale negativo, revisa el codigo a ver.

[GatorV]

Que version de PHP tienes?

Corri tu script en mi servidor de produccion, la salida:

Código:

Test1:
Haciendo 100000 ciclos; Incrementando con ++; Tiempo inicial: 1180550489.02
Fin; 1180550489.04
Diferencia: 0.0267841815948




Test2:
Haciendo 100000 ciclos; Incrementando con += $i; Tiempo inicial: 1180550489.04
Fin; 1180550489.07
Diferencia: 0.0228390693665




200000 = 200000
Con ++: 0.0267841815948
Con +=: 0.0228390693665

Sigue siendo mas rapido += jeje.

[wrkjmg]

Vale, ya esta claro , mi server tiene la version 4.6 y no soporta true en microtime. Y el PHP no me dice nada.

[GatorV]

Prueba esta funcion:

Código PHP:

  function fmicrotime() {
      return array_sum( explode( ' ', microtime() ) );
}  
   

[wrkjmg]

Gracias por la funcion Gatorv

[AlvaroG]

Sé que llego tarde a la discusión, pero el tema de la optimización me interesa (soy un bicho de bajo nivel jejejeje).

Según tu explicación, wrkjmg,
$variable += X; (siendo X un entero) lleva 4 o 5 ciclos
No especificaste si lleva la misma cantidad de ciclos para cualquier X, así que asumo que es así.

Por otro lado, $variable++ lleva 1 ciclo.

Lo que me lleva a la conclusión de que si X es mayor que 5, es más eficiente hacer el ADD (ya que sumar 10, como hace GatorV en su prueba, me llevaría 10 ciclos de procesador, uno por cada INC), o mejor dicho el +=.

Igual de todas formas creo que PHP no es un lenguaje que permita ver diferencias entre tanto detalle, ya que al ser interpretado no creo que se "pierda" tiempo en ver si se traduce el += a ++ o no, esa comprobación quizás lleve más tiempo del que se gana usando un método u otro. Sin embargo, como me interesa el C, intentaré recordar esto :risa


Saludos.

[wrkjmg]

Bueno Alvin , en realidad solo pretendia dar un ejemplo, PHP es un lenguaje que se interpreta en tiempo real , con lo que no tiene nada que ver con C en lo referente a compilacion y demas.
La cuestion es que esto lo puse como ejemplo, mi entencio era hacer ver que optimizar el codigo para mejorar el rendimiento no significa que el codigo tenga que tener menos lines ó que tenga que tener una estructura mas bonita y legiblel. Si no que a veces es justo lo contrario. Por ejemplo otro de los puntos que se usaban en C, repito que hablo de C porque es el que conozco, eran el hecho de intentar reducir el numero de bucles necesarios lo maximo posible. Ejemplo:

for($i =0 ; $i<5 ; $i++)
{
$myvar[$i] += 10;
}

Aqui usamos el bucle solo para no tener que escribir esto:

$myvar[0] += 10;
$myvar[1] += 10;
$myvar[2] += 10;
$myvar[3] += 10;
$myvar[4] += 10;


Y creo que aqui si que esta claro que la segunda opcion utiliza muchos menos recursos. Pero claro , uno ve el codigo de la segunda opcion y piensa, pffff que patatero el tio que ha escrito esto, no tiene ni idea.

Estos temas sobre optimizacion preocupaban mucho mas antes, ahora ya no tienen mucha importancia porque antes un micro iva a 80MHz y ahora un micro va a 3GHz, un ciclo de antes eran 1/80.000.000 Segundos y ahora son 1/3.000.000.000, ya no merece la pena hilar tan fino. Pero claro, si aprieta la necesidad......

Por cienrto en INC y el DEC eran 2 ciclos, puse uno para exagerarlo mas y que fuese mas claro el ejemplo. Lo siento si confundi a alguien. En realidad solo salia mas rentable para el caso de $variable+=2, para el caso de $variable+=3 ya no servia.

[AlvaroG]

Para mí siempre es interesante conocer esa clase de cosas, así que ojalá hagas más comentarios como éstos por el foro


saludos.

[goc00]

WUAU, en lo que terminó el post! XD; por cierto, bastante interesante el tema. Gracias por compartirlo (mientras tanto, yo sigo craneando stored procedures para este procedimiento) ¬¬