Ejercicio: Cual es el más rápido (Counter, variables locales o globales)

En distintas ocasiones se ha preguntado cual es más rápido de los siguientes medios que nos permiten almacenar variables:

- Counter
- Variables locales
- Variables globales

El ejercicio consiste en verificar cual de ellas es la más rápida.
Hacer la comprobación para operadores aritméticos (suma, por ejemplo) y comparadores (menor que, por ejemplo).

No hay puntos, ni premios, ni fechas, ni na de na.
Tan sólo una excusa para reabrir esta sección y de paso resolver esta cuestión de una vez por todas.

Veremos a quién se le ocurre la solución más elegante.

Edito: Sería de desear que en lo posible se posteasen los .mfa en la versión de MMF, para que la mayoría de usuarios puedan verlos.

Bueno, al parecer es lo mismo.

más rápido

Saludos!

ErichZann escribió:

Bueno, al parecer es lo mismo.

más rápido

Saludos!

En primer lugar, agradecerte tu participación.

En cuanto a la propuesta, pues bueno, un primer intento... pero en esta ocasión...  

Aquí lo que haces es sumar una unidad a cada "variable" por cada fps.

Es decir, si pones la velocidad de refresco a 100 fps, el tiempo que tarda en refrescarse el frame 1000 veces, será 1000/100 = 10 segundos.

Resumiendo, no estás midiendo la velocidad de las "variables" sino cuanto tiempo se tarda en "ejecutar" 1000 ciclos (frames) a la velocidad del framerate (fps) que se haya puesto (en tu caso fps=60).

es que para medir el rendimiento tal vez tendríamos que saturar un poco el sistema

Tal vez con el tipico test de crear actives y contarlos usando un counter en un frame, en otro frame una variable local y en otro un variable global.

y a ver como se comportan en cada caso

o hacer algún tipo de operación compleja que requiera bastante tiempo para procesarla.

Zonacas escribió:

es que para medir el rendimiento tal vez tendríamos que saturar un poco el sistema

Tal vez con el tipico test de crear actives y contarlos usando un counter en un frame, en otro frame una variable local y en otro un variable global.

y a ver como se comportan en cada caso

o hacer algún tipo de operación compleja que requiera bastante tiempo para procesarla.

Bueno, tal vez haya algún modo de escribir un valor en una variable un montón de veces en un lapso corto de tiempo ? Si fuera así, tal vez se pueda medir cuanto tiempo tarda en hacerlo unas cuantas miles de veces o tal vez se pueda medir cuantas veces se puede escribir un valor en un tiempo dado ?

En resumen, tiene toda la pinta de que un "fastloop" o un "ForEach" nos pueden servir, para realizar la prueba.

Hola gente!

Estado leyendo este post y me a parecido interesante. Enseguida me he puesto a investigar como hacerlo y aquí os traigo un ejemplo que a mi parecer funciona.

Ahora solo falta que vosotros lo veáis, y deis el visto bueno o simplemente desmintáis la teoría.


Os voy a explicar como funciona:

Se trata de una cuenta atrás que va desde 100 a 0. Esta cuenta atrás la efectúan al mismo tiempo un counter, una variable local, y otra variable global.

Luego lo que sucede es sencillo. El primero que llegue a 0, el programa salta a un nuevo frame anunciando el ganador.

Solo añadir, que los 3 counters que se ven en el centro de la pantalla, son solamente visuales para poder ver la cuenta atrás. (Era solo por hacerlo un poco bonito, nada mas.)

El counter que hay arriba del frame, es el que realmente cuenta, luego al lado hay un active que uso para la variable local, y luego en una variable global esta el otro contador.

Yo estado probando a que haga la cuenta atrás solo dos de ellos para ver cuales son mas rápidos. Y visto lo visto, el mas rápido es el Global, el segundo mas rápido el Local, y el mas lento el counter.


Bueno os dejo el link haber si esta todo correcto o hay algo que haga que suceda así.

LINK: https://dl.dropboxusercontent.com/u/63334699/Solucionar%20problemas/El%20Mas%20Rapido.mfa


Un saludo y espero vuestras respuestas que esto me tiene intrigado ejejej. ( Lo digo así porque vosotros sabéis mucho mas que yo, y hasta que no deis vuestro visto bueno no me doy por satisfecho )

Parece que el mas rápido es la Global Value, luego la variable del active y luego el counter

y es así aun cambiando el orden de las acciones

parece lógico que una variable sea más rápida que cualquier objeto

Mart393 escribió:

Hola gente!

Estado leyendo este post y me a parecido interesante. Enseguida me he puesto a investigar como hacerlo y aquí os traigo un ejemplo que a mi parecer funciona.
...

Gracias Mart por participar.

Sabía que el ejercicio tenía su miga y de hecho estaba esperando una solución de este tipo.

Pero lo cierto, es que estamos en el mismo caso que el que ya planteó Erich y no sirve para decidir.

Explicación:

Las tres "variables" responden de forma equivalente frame a frame. En realidad en cada frame se verifican de igual modo las tres condiciones, cuando las tres son verdaderas.

Entonces, ¿ por qué en el ejemplo, el salto a la solución es la de la variable global ?

Si bien el orden de las sentencias que ejecutan la resta es irrelevante, lo que si importa es el orden de los eventos 7, 8 y 9. Estas tres condiciones se "comprueban" frame a frame (realmente solo importa el último, cuando se pasa en las distintas variables de 1 a 0, verificándose en este caso).

Como se verifican las tres, el sistema escoge una para ser ejecutada y lo que hace es ejecutar la más reciente o lo que es lo mismo... la última.

Demostración:

Podemos intercambiar las posiciones 7, 8 y 9 y veremos como la orden de "salto de frame" que se va a ejecutar es la de la condición en el evento 9 (el último).

Buen intento... pero...  

Vaya!!!, es verdad. siempre pilla el evento 9 habrá que idear otro test

Ya me parecía que le estaba apuntando al cura y pegando al campanario.... Voy a ver que otra cosa se me ocurre...

Salute!

Bueno visto que no he dado con la solución, y después de estar mas de 18 horas calentándome la cabeza, por fin, y ahora si que si, os traigo la prueba definitiva de cual es el mas rápido de los tres.

Aquí os dejo el link y juzgad por vosotros mismos!

https://dl.dropboxusercontent.com/u/63334699/Solucionar%20problemas/El%20Mas%20Rapido%20-%20Ara%20Si%20Que%20Si.mfa

PD: Espero que no me baneen por esto...  

Pero... no vale poner lastre a los demás ! Pobres !

Mart393 escribió:

Bueno visto que no he dado con la solución, y después de estar mas de 18 horas calentándome la cabeza, por fin, y ahora si que si, os traigo la prueba definitiva de cual es el mas rápido de los tres.

Aquí os dejo el link y juzgad por vosotros mismos!

https://dl.dropboxusercontent.com/u/63334699/Solucionar%20problemas/El%20Mas%20Rapido%20-%20Ara%20Si%20Que%20Si.mfa

PD: Espero que no me baneen por esto...  

 

(Donde habré puesto las tarjetas rojas?... voy a ver si las encuentro )


--------------------------------------------------------------------------

Aquí va mi Test

TestVariables.mfa


Parece claro que el counter es el mas lento de todos, y que la global value es el más rápido, seguido de cerca por la variable de un objeto active.

mm interesante! parece ser que esa forma es mas fiable para lo que estábamos probando.

Haber que le parece alpupas.
Muy bien zon!

PD: Os podéis creer que a dia de hoy, todavía no se como funcionan los loops?

Zonacas escribió:

TestVariables.mfa

Parece claro que el counter es el mas lento de todos, y que la global value es el más rápido, seguido de cerca por la variable de un objeto active.

Bueno... esta prueba es...   

Se podría hacer con ForEach y de paso ver cual de los dos es más rápido (FastLoops o ForEach) ?

En todo caso, se comprueba que para operadores aritméticos (una suma en este caso), las variables globales (asignadas a la aplicación) son un poco más rápidas que las variables locales (asignadas a objetos) y bastante más rápidas que los counters (asignados al frame).

Pero... y para operadores de comparación ? Por ejemplo, "menor que".
Habría que hacer la prueba... quizás haya sorpresas !!!