sweblog · Blog von Sebastian Weyrauch

Heute habe ich mich nochmals mit dem neuen Typ Vector im Flash Player 10 beschäftigt. Dafür habe ich eine einfache Testklasse gebaut, die meine Test-Szenarios 100000mal durchläuft. Mir ging es in erster Linie darum grobe Unterschiede festzustellen. Für genauere Ergebnisse, muss man das sicherlich etwas verfeinern.

Die Messung

var startTime:int = getTimer();

for(var i:int = 0; i<100000; i++)
{
   testCase();
}

var duration:int = getTimer()-startTime;

Test 1 - Definieren und Befüllen

Zunächst habe ich untersucht, wie es sich mit der Performance beim einfachen Definieren und Befüllen mit Werten verhält.

Die Array Variante:

var simpleList:Array = new Array(10);
var n:int = simpleList.length;

for(var i:int = 0; i<n ; i++) simpleList[i] = i;

Die Vector Variante:

var fixedIntList:Vector.<int> = new Vector.<int>(10, true);

var n:int = fixedIntList.length;
for(var i:int = 0; i<n ; i++) fixedIntList[i] = i;

Hier konnte ich relativ große Unterschiede feststellen. Während die Array Variante im Schnitt 370ms benötigt hat, lief die Vector Variante mit ca. 200ms im Schnitt fast doppelt so schnell.

Test 2 - Zugriff auf Werte

Danach habe ich natürlich getestet, wie es sich mit dem Zugriff auf die einzelnen Werte verhält. Gerade durch die Typisierung der einzelnen Werte, habe ich mir hier einiges erhofft. Jedoch bin ich mir noch nicht ganz so schlüssig, wie ich das Ergebnis werten soll.

Dazu habe zunächst ich ein Szenario mit Sprites gewählt, auf die ich zugreife (hier der Fall mit dem Array):

var simpleList:Array = new Array(10);

// fill with some dummy sprits
for(var k:int = 0; k<10; k++) simpleList[k] = new Sprite;

var n:int = simpleList.length;
for(var i:int = 0; i<n ; i++)
{
   var s:Sprite = Sprite(simpleList[i]);
   addChild(s);
   removeChild(s);
}

Jedoch half mir dieser Test nicht weiter, da der Zugriff auf den Wert einen zu kleinen Teil der Berechnungen darstelle, klar. Daher habe ich vorher bereits mein Array erstellt und alles auf das Wesentliche reduziert.

Einmal ohne Cast:

var n:int = simpleList.length;
for(var i:int = 0; i<n ; i++)
{
   var s1:Sprite = simpleArray[i];
   var s2:Sprite = simpleArray[i];
   var s3:Sprite = simpleArray[i];
   var s4:Sprite = simpleArray[i];
   var s5:Sprite = simpleArray[i];
}

Einmal mit:

var n:int = simpleList.length;
for(var i:int = 0; i<n ; i++)
{
   var s1:Sprite = Sprite(simpleArray[i]);
   var s2:Sprite = Sprite(simpleArray[i]);
   var s3:Sprite = Sprite(simpleArray[i]);
   var s4:Sprite = Sprite(simpleArray[i]);
   var s5:Sprite = Sprite(simpleArray[i]);
}

Im ersten Fall hatte ich im Schnitt 150ms, im letzteren ca. 740ms.

Nun ist natürlich das Ergebnis vom Vector interessant.

var n:int = fixedSpriteList.length;
for(var i:int = 0; i<n ; i++)
{
   var s1:Sprite = fixedSpriteList[i];
   var s2:Sprite = fixedSpriteList[i];
   var s3:Sprite = fixedSpriteList[i];
   var s4:Sprite = fixedSpriteList[i];
   var s5:Sprite = fixedSpriteList[i];
}

Hier kam ich im Schnitt auf 125ms. Zwar ein etwas besserer Wert als bei dem Array ohne Cast, jedoch hatte ich mit größeren Unterschieden gerechnet.

Falls jemand eine Idee hat, warum in meinen Tests die Unterschied so gering sind, freue ich mich über jeden Tipp.

Fazit

Selbst wenn nach meinen Tests die Performance Unterschiede nicht allzu groß sind, bringen Vectors (typisierte Arrays) Vorteile für Entwickler. Denn durch die Typsicherheit können einige Fehler gut vermieden werden. Denn Compile-Time Fehler sind besser als Runtime Fehler. Und wenn die Editoren diese Syntax bald noch unterstützen, kann man diese noch früher beseitigen.