ActionScript 3 Vector vs Array Performance test

By
Lode
Published: 29 July 2010 8:04 PM UTCPosted in: ActionScript, Air, Flash, Flex, RIA, Web Applications, WebdesignTags: , , , , , ,
ActionScript 3 Vector vs Array Performance test

Interesting article about the new Vector feature in flash player 10, thanks to Mike Chambers for this article

In my original post on the new Flash Player 10 Vector class, I did a simple example that showed Vectors being slightly faster than Array when just populating and looping through collections.

Below is another example that shows a more significant performance increase when using Vectors. In this example, I populate an Array and Vector with 5 million random numbers, and then loop through them and average all of the numbers.

Running the test on my MacBook Pro, the Vector is about 60% faster:

Vector 1.824
Array 2.938
62.08 %

Here is the code:

package {
    import flash.display.Sprite;
    import __AS3__.vec.Vector;

    public class VectorPerformance extends Sprite
    {
        private static const LENGTH:int = 5000000;

        public function VectorPerformance()
        {
            //vector performance
            var vectorStartTime:Number = getTime();

            var v:Vector.<Number> = generateVector();
            var vAvg:Number = averageVector(v);

            var vectorTime:Number = (getTime() - vectorStartTime) / 1000;

            //array performance
            var arrayStartTime:Number = getTime();

            var a:Array = generateArray();
            var aAvg:Number = averageArray(a);

            var arrayTime:Number = (getTime() - arrayStartTime) / 1000;

            trace("Vector", vectorTime);
            trace("Array", arrayTime);
            trace((vectorTime/arrayTime) * 100 + " %");
        }

        private function generateVector():Vector.<Number>
        {
            var v:Vector.<Number> = new Vector.<Number>(LENGTH, true);

            for(var i:int = 0; i < LENGTH; i++)
            {
                v[i] = Math.random() * 100000;
            }

            return v;
        }

        private function averageVector(v:Vector.<Number>):Number
        {
            var sum:Number = 0;
            var len:int = v.length;

            for(var i:int = 0; i < LENGTH; i++)
            {
                sum += v[i];
            }

            return (sum / len);
        }

        private function generateArray():Array
        {
            var a:Array = new Array(LENGTH);

            for(var i:int = 0; i < LENGTH; i++)
            {
                a[i] = Math.random() * 100000;
            }

            return a;
        }

        private function averageArray(arr:Array):Number
        {
            var sum:Number = 0;
            var len:int = arr.length;

            for(var i:int = 0; i < LENGTH; i++)
            {
                sum += arr[i];
            }

            return (sum / len);
        }      

        private function getTime():Number
        {
            return (new Date()).getTime();
        }
    }
}

Of course, this is only one test. Depending on what you are doing, Vectors may be even faster, or slower.

One interesting note, originally my test had each collection sorted before they were averaged, but it turned out that sorting Vector was slower than sorting the Array. Not sure if this is a bug, but I have reported it to the player team.

About the Author

Lode is a Creative-Geek with passion for Graphic design , he is also into the web programming "stuff" like Adobe Flash,air and Flex . Lode loves to learn and loves to share knowledge with others.Follow Lode on http://twitter.com/stealfish