Actionscript 3.0: optimizaciones (I)
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 3 4 5 6 7 8 |
var t:Number = getTimer(); var temp:int; for(var i:Number = 0; i < matriz.length; i++){ temp = matriz[i]; } trace(getTimer() - t); |
Resultado: 130 ms
Si sustituimos el tipo de i de Number a uint:
1 2 3 4 5 6 7 8 |
var t:Number = getTimer(); var temp:int; for(var i:uint = 0; i < matriz.length; i++){ temp = matriz[i]; } trace(getTimer() - t); |
Resultado: 95 ms
Si almacenamos matriz.length en una variable:
1 2 3 4 5 6 7 8 9 |
var t:Number = getTimer(); var temp:int; var l:uint = matriz.length; for(var i:uint = 0; i < l; i++){ temp = matriz[i]; } trace(getTimer() - t); |
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 3 4 5 6 7 8 |
var t:Number = getTimer(); var temp:Number; for(var i:uint = 0;i < 1000000; i++){ temp = Math.floor(1.7); } trace(getTimer() - t); |
Resultado: 163 ms
1 2 3 4 5 6 7 8 |
var t:Number = getTimer(); var temp:Number; for(var i:uint = 0;i < 1000000; i++){ temp = uint(1.7); } trace(getTimer() - t); |
Resultado: 29 ms
1 2 3 4 5 6 7 8 |
var t:Number = getTimer(); var temp:Number; for(var i:uint = 0;i < 1000000; i++){ temp = int(1.7); } trace(getTimer() - t); |
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 3 4 5 6 7 8 9 |
var t:Number = getTimer(); var temp:Number; var n:Number = -53.44; for(var i:uint = 0;i < 1000000; i++){ temp = Math.abs(n); } trace(getTimer() - t); |
Resultado: 145 ms
1 2 3 4 5 6 7 8 9 |
var t:Number = getTimer(); var temp:Number; var n:Number = -53.44; for(var i:uint = 0;i < 1000000; i++){ temp = n < 0 ? n * -1 : n; } trace(getTimer() - t); |
Resultado: 26 ms
Es decir, obtener el valor absoluto "a mano", 5,5 veces más rápido que utilizar Math.abs()
COMENTARIOS
Increibles resultados Dani
yo también lo flipo con algunos valores. Ya había oido algo al respecto, hay quien después de hacer un proyecto se dedica a cambiar los Math.abs para hacerlos a mano y cosas así…
A mi me ha sorprendido mucho lo de Math.floor y Math.abs. Que recorrer una matriz indicando uint como tipo de i, y almacenando el valor máximo en una variable sea más rápido que hacerlo «a lo bruto» lo entiendo, pero lo otro…
Wow, muy buen ejercicio, has resuelto definitivamente mis dudas respecto a Number/uint/int.
Lo del Math.floor más que sorprendente es vergonzoso XD
Muy buen analisis de tiempos, increible. pero hay que ser comprensivos con Math.floor(), simplemente es un viejo agradable y elegante.
En general, llamar a una función siempre es lento. Ya sea una del propio api como Math.abs o Math.floor. Por eso si necesitas optimizar un código lo más provechoso es eliminar llamadas a funciones externas. En todo caso, un casting (a cualquier tipo) o una operación como la multiplicación o comparación siempre será mas rapida ya que no compromete manipular el stack de la memoria. Pero, como dice Richi, esto es mas elegante y legible usar los metodos. Asi que si el código en si, no necesita ser rapido (el 98% de las veces) mejor usarlo.
tio eres la caña, estoy flipando con la cantidad de megatutoriales que te has currado. Mira yo no suelo escribir en ninguna página de las que veo, soy muy perro hasta para escribir, pero de verdad, con gente como tu este mundo es mejor… parece que exagero, pero a mi me ha venido muy bien, asique solo puedo decirte que MUCHISIMAS MUCHISIMAS GRACIAS!!!, OTRA VEZ GRACIAS!!!
@gabatx: gracias, normalmente los que mas se esfuerzan en comentar son el 0,1% de trolls que lo que quieren es que les hagas el trabajo. Son el 0,1% pero hacen el 90% del ruido, asi que está bien saber que esto le vale a alguien :)
DEJA TU COMENTARIO