Actionscript 3.0: optimizaciones (I)

Actionscript 3.0: optimizaciones (I)

Etiquetas: Math.floor Math.abs

Este artículo recoge algunos test de rendimiento para diversas operaciones en Actionscript 3.0. Este es un tema que me interesa bastante, asi que espero hacer mas test e ir ampliando información en el futuro.

Los test se han realizado en un Core2 6420 2,13Ghz, con 3GB de RAM y Windows Vista Home Premium de 32 bits. La versión de Flash Player es la 10,0,2,54.

 

Recorrer elementos de un Array (de 1 millón de elementos)

  1.  
  2. var t:Number = getTimer();
  3. var temp:int;
  4. 	for(var i:Number = 0; i < matriz.length; i++){
  5. 		temp = matriz[i];
  6. 	}
  7. trace(getTimer() - t);
  8.  

Resultado: 130 ms

 

Si sustituimos el tipo de i de Number a uint:

  1.  
  2. var t:Number = getTimer();
  3. var temp:int;
  4. for(var i:uint = 0; i < matriz.length; i++){
  5. 	temp = matriz[i];
  6. }
  7. trace(getTimer() - t);
  8.  

Resultado: 95 ms

 

Si almacenamos matriz.length en una variable:

  1.  
  2. var t:Number = getTimer();
  3. var temp:int;
  4. var l:uint = matriz.length;
  5. for(var i:uint = 0; i < l; i++){
  6. 	temp = matriz[i];
  7. }
  8. trace(getTimer() - t); 
  9.  

Resultado: 23 ms

 

En definitiva, solo con poner uint (entero positivo) como tipo de i, y con almacenar la longitud de la matriz en una variable, hacemos que el bucle se ejecute 5,6 veces más rápido.

 

Redondear números (Math.floor)

  1.  
  2. var t:Number = getTimer();
  3. var temp:Number;
  4. for(var i:uint = 0;i < 1000000; i++){
  5. 	temp = Math.floor(1.7);
  6. }
  7. trace(getTimer() - t);
  8.  

Resultado: 163 ms

 

  1.  
  2. var t:Number = getTimer();
  3. var temp:Number;
  4. for(var i:uint = 0;i < 1000000; i++){
  5. 	temp = uint(1.7);
  6. }
  7. trace(getTimer() - t); 
  8.  

Resultado: 29 ms

 

  1.  
  2. var t:Number = getTimer();
  3. var temp:Number;
  4. for(var i:uint = 0;i < 1000000; i++){
  5. 	temp = int(1.7);
  6. }
  7. trace(getTimer() - t);
  8.  

Resultado: 18 ms

 

Este test me ha sorprendido mucho. Convertir el número a int(entero), es 9 veces más rápido que utilizar Math.floor(). Teniendo en cuenta que el resultado es el mismo, y que encima int tiene menos letras que Math.floor, no veo motivos para no desterrar a Math.floor().

 

Obtener el valor absoluto de un número (Math.abs)

  1.  
  2. var t:Number = getTimer();
  3. var temp:Number;
  4. var n:Number = -53.44;
  5. for(var i:uint = 0;i < 1000000; i++){
  6. 	temp = Math.abs(n);
  7. }
  8. trace(getTimer() - t); 
  9.  

Resultado: 145 ms

  1.  
  2. var t:Number = getTimer();
  3. var temp:Number;
  4. var n:Number = -53.44;
  5. for(var i:uint = 0;i < 1000000; i++){
  6. 	temp = n < 0 ? n * -1 : n;
  7. }
  8. trace(getTimer() - t); 
  9.  

Resultado: 26 ms

Es decir, obtener el valor absoluto "a mano", 5,5 veces más rápido que utilizar Math.abs()