1. Inicio
  2. Pregunta y respuesta
  3. AS3 Vector de matrices

AS3 Vector de matrices

2011-12-18 13 views
6

¿Hay algún beneficio de rendimiento en el almacenamiento de matrices en un vector de tipo matriz?AS3 Vector de matrices

por ejemplo Opción 1

private var _arrays:Vector.<Array> = new Vector.<Array>(2); 
_arrays[0] = new Array(10); 
_arrays[1] = new Array(10);

Opción 2

private var _arrays:Array = new Array(2); 
_arrays[0] = new Array(10); 
_arrays[1] = new Array(10);

también puedo tener un vector o vectores?

private var _vectors:Vector.<Vector> = new Vector.<Vector>(2); 

_vectors[0] = new Vector.<String>(10); 
_vectors[1] = new Vector.<String>(10);

Gracias,

Marcos

Fuente

2011-12-18 crooksy88

+0

Ver mi respuesta actualizada @ crooksy88. Publiqué el resultado del código de prueba + que muestra que mi original es correcto y la respuesta de weltraumpirat es evidentemente falsa. –

Respuesta

10

EDITAR

Mi respuesta original estaba mal excepto por la última parte, y tengo que disculparme por eso. Sabía de hecho que Vector tiene exactamente cuatro implementaciones "bajo el capó". (Puede encontrar fuentes decompiladas de FP 10 playerglobal.swc en una publicación de Robert Penner here). Tres de ellas son para tipos de números (int, uint y Number). Uno es para tipos de objetos. Este último sirve como un catch-all y abarca todas las clases derivadas de Object. Esta es la razón por la que asumí que Vector.<Object> era aún más rápido que Array, dependiendo de the information regarding vectors and arrays available from Adobe.

Sin embargo, parece que esta información es incorrecta, o al menos deja fuera algunas partes importantes:

  1. Mientras Vector.<AnyClassDerivedFromObject> permite la tipificación estricta, este tipo de información sólo se evalúa en tiempo de compilación (por lo que obtener más seguridad de tipo), pero no en tiempo de ejecución, por lo tanto, esencialmente los beneficios de los vectores de objeto de tipeo estrictos no se aplican al rendimiento. Vea this blog post para más información.

  2. En consecuencia, las únicas implementaciones de Vector que son más rápidas que Array son las de los tipos de número (!).

De hecho, he hecho algunas pruebas exhaustivas en esto, y han llegado a la conclusión de que, si bien Vector.<int> es hasta un 60% más rápido que la matriz de INT, todos los derivados de Vector.<Object> no sólo son iguales en la velocidad (es decirVector.<Object> realiza lo mismo que Vector.<String>, también son aproximadamente 20% más lento que Array. He verificado esto dos y tres veces, así que creo que los resultados son bastante precisos.

Todavía es cierto que los vectores de tipo de número son más rápidos, por lo que debe utilizarlos para obtener beneficios de rendimiento sobre Array. Pero:

FIN EDITAR

Sólo si se va a utilizar sort(), sortOn() o cualquier otra de las funciones de clasificación conveniente de la matriz, es posible que aún decidir lo contrario, ya que estos son funciones nativas, y como tal realmente rápido. La implementación de sus propios métodos de clasificación en un Vector probablemente no coincidirá con su velocidad.

Fuente

2011-12-18 12:34:52 weltraumpirat

+1

No veo cómo un 'Vector. 'puede ser más rápido que un' Array'. ¿Podrías explicar por qué es esto? –

6

que personalmente no puede ver ninguna ventaja de rendimiento. Si hay alguno, será mínimo. El objetivo de tener la clase vectorial es escribir estrictamente los elementos de una matriz. Pero, un objeto de matriz en sí está diseñado para contener múltiples tipos de objetos o incluso sin tipo ... tan estrictamente escribiendo un vector en un contenedor esencialmente sin tipo que puede llenarse con contenidos sin tipo o múltiples, de varios tipos ... cuando se piensa de esta manera simplemente suena lógicamente que tendrá poco o ningún efecto.

actualización

He aquí algunos resultados de las pruebas de rendimiento para probar mi punto. Podemos ver que cuando se ponen bajo estrés, el vector de matrices es igual al rendimiento como una matriz de matrices, y en un caso de prueba, en realidad es aún peor:

/ ============================================================================================= 
            Array Tests            
=============================================================================================/
Testing Array of Arrays push performance: 
Total time for 100000 push calls on Array of Arrays: 24 

Testing Array of Arrays random assignment performance: 
Total time for 100000 random assignment calls on Array of Arrays: 40 

Testing Array of Arrays sequential read performance: 
Total time for 100000 sequential read calls on Array of Arrays: 14 

Testing Array of Arrays random read performance: 
Total time for 100000 random read calls on Array of Arrays: 41 
/=============================================================================================/

/============================================================================================= 
            Vector Tests            
=============================================================================================/
Testing Vector of Arrays push performance: 
Total time for 100000 push calls on Vector of Arrays: 24 

Testing Vector of Arrays random assignment performance: 
Total time for 100000 random assignment calls on Vector of Arrays: 49 

Testing Vector of Arrays sequential read performance: 
Total time for 100000 sequential read calls on Vector of Arrays: 14 

Testing Vector of Arrays random read performance: 
Total time for 100000 random read calls on Vector of Arrays: 41 
/=============================================================================================/

Y el código de prueba:

import flash.events.Event; 
import flash.utils.getTimer; 

//Performance timer related 
var startTime:Number; //ms 
// 

//Our two container types we're testing IO on 
var arrayOfArrays:Array = new Array(); 
var vectorOfArrays:Vector.<Array> = new Vector.<Array>(); 
// 

//Used to store a bunch of arrays we're going to use to test 
var testArrays:Array = new Array(); 
// 

var randomIndex:uint = 0; 
var i:uint = 0; 
var arr:Array; 

//Generate a bunch of arrays of mixed typed content 
for(i = 0; i < 100000; ++i) { 
    generateTestArray(); 
} 

/*====================================================================================================== 
***********************************  Array Tests  ********************************************* 
*=====================================================================================================*/ 
//Test push on array of arrays 
trace("Testing Array of Arrays push performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    arrayOfArrays.push(testArrays[i]); 
} 
trace("Total time for 100000 push calls on Array of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 

//Test random write on array of arrays 
trace("Testing Array of Arrays random assignment performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    randomIndex = Math.round(Math.random() * 99999) as uint; 
    arrayOfArrays[randomIndex] = testArrays[randomIndex]; 
} 
trace("Total time for 100000 random assignment calls on Array of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 

//Test sequential read on array of arrays 
trace("Testing Array of Arrays sequential read performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    arr = arrayOfArrays[i]; 
} 
trace("Total time for 100000 sequential read calls on Array of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 

//Test random read on array of arrays 
trace("Testing Array of Arrays sequential read performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    randomIndex = Math.round(Math.random() * 99999) as uint; 
    arr = arrayOfArrays[randomIndex]; 
} 
trace("Total time for 100000 random read calls on Array of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 
/*====================================================================================================*/ 


/*====================================================================================================== 
***********************************  Vector Tests  ********************************************* 
*=====================================================================================================*/ 
//Test push on vector of arrays 
trace("Testing Vector of Arrays push performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    vectorOfArrays.push(testArrays[i]); 
} 
trace("Total time for 100000 push calls on Vector of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 

//Test random write on vector of arrays 
trace("Testing Vector of Arrays random assignment performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    randomIndex = Math.round(Math.random() * 99999) as uint; 
    vectorOfArrays[randomIndex] = testArrays[randomIndex]; 
} 
trace("Total time for 100000 random assignment calls on Vector of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 

//Test sequential read on vector of arrays 
trace("Testing Vector of Arrays sequential read performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    arr = vectorOfArrays[i]; 
} 
trace("Total time for 100000 sequential read calls on Vector of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 

//Test random read on vector of arrays 
trace("Testing Vector of Arrays sequential read performance:"); 
startTime = getTimer(); 
for(i = 0; i < 100000; ++i) { 
    randomIndex = Math.round(Math.random() * 99999) as uint; 
    arr = vectorOfArrays[randomIndex]; 
} 
trace("Total time for 100000 random read calls on Vector of Arrays: " + (getTimer() - startTime)); 
trace(" "); 
// 
/*====================================================================================================*/ 

function generateTestArray():void 
{ 
    var newArray:Array = new Array(); 

    var totalItems:uint = Math.round(Math.random() * 50 + 1); 

    var i:uint = 0; 

    var dice:uint = 0; 

    for(i; i < totalItems; ++i) { 

     dice = Math.round(Math.random() * 5); 

     switch(dice) { 
      case 0: 
       newArray.push(new int(Math.random())); 
      break; 

      case 1: 
       newArray.push(new String(Math.random())); 
      break; 

      case 2: 
       newArray.push(new Array()); 
      break; 

      case 3: 
       newArray.push(new MovieClip()); 
      break; 

      case 4: 
       newArray.push(new Date()); 
      break; 

      case 5: 
       newArray.push(new Event(Event.COMPLETE, false, false)); 
      break; 

     } 
    } 

    testArrays.push(newArray); 
}

Fuente

2011-12-18 12:04:01

Cuestiones relacionadas

 Cuestiones relacionadas