boostworthyisryantaylor

A lot of debate exists over AS3 performance in regards to things such as numerical data types, loops, timers, and enter frame events. While I’m in the process of porting my animation system over to AS3, what better time to do some testing to ensure that it is as optimized as possible.

Loops and Numerical Data Types

I sampled my three favorite loops for this experiment; they are as follows:

Test #1: for(var i:(Number, int, uint) = 0; i < 1000000; i++)

Test #2: for(var i:(Number, int, uint) = 1000000 - 1; i > -1; i--)

Test #3: var i:(Number, int, uint) = 1000000; while(i--)

Inside the loops was some simple math:

var nRandom:Number = Math.random() * 100;

Also note that I tried both pre and post operations (i++, ++i, i--, --i) for each loop and found no change in results. Each loop was ran 50 times to gather an average, and then I ran the test many times to ensure that I was getting the best results possible. Here is what I gathered.

Results in millseconds:

50-average, 100000 loop, Number

Test #1: 230.54 (228.82 on additional test)
Test #2: 235.54
Test #3: 233.36 (228.63 on additional test)

50-average, 100000 loop, int

Test #1: 239.82
Test #2: 268.38
Test #3: 266.7

50-average, 100000 loop, uint

Test #1: 15 second timeout occured
Test #2: 15 second timeout occured
Test #3: 15 second timeout occured

As you can see, when 'i' was typed as an uint performance was so bad that the Flash 15 second timeout was thrown before the test completed. Equally note-worthy is the fact that Numbers out-performed ints.

Next, I decided to do some tests with arrays in loops. I created an indexed array containing 100 elements, each of which was a string with 4 to 20 characters. I ran the same tests as last time, however this time I did not test uint. The test results were all pretty close, Test #’s 1 and 3 were basically dead even. Here is the interesting part; In AS2, despite all the best practices and stuff preaching this:


var nLength:Number = aList.length;
for(var i:Number = 0; i < nLength; i++)


I still found that it was faster to plug the array length property directly into the loop:


for(var i:Number = 0; i < aList.length; i++)


I was very insecure with these results, but I tested things again and again and found the same thing. Now, in AS3, setting a variable with the array length and then using that in the loop is finally faster, and quite a bit at that (0.024ms compared to 0.034ms).

One final thing before we move on. If you are looping through an array and 'i' is only being used to access an index in your array, I recommend typing 'i' as an int. If 'i' is of type Number, it actually slows the loop down a bit from what I have seen. If you are using 'i' in the loop for some math as well, typing it as a Number is fine, but to pick up some performance, make sure you type cast 'i' as int when passing it into the array.

or

Enter Frame Event and Timers

Before we begin, I just want to clarify a few important points. There is a time and a place for both the enter frame event and for timers, the key is knowing when and why to use them in your architecture. Let’s examine the enter frame event first.

We begin by adding a new listener for the enter frame event:

In the above example, a listener is added to the object in which the code is placed in, and the method 'OnLogTime' will be called at the corresponding framerate of the SWF file. For example, if the typical 31 frames per second is set, the enter frame event will be dispatched every 32 milliseconds approximately (1000 / 31 = 32.258). I created a simple test which logs the time in milliseconds between each time the event handler is called.

Average: 34.31 milliseconds from 100 samples.

Not bad. Only around 2 milliseconds were lost in between the time the event occured, it was dispatched, and the handler recorded the time. Now let’s take a look at Timers.

That’s enough to have our test up and running with a Timer this time, as opposed to listening for the enter frame event. It’s important to note that the event handler will be getting called every 15 milliseconds this time, as opposed to every 32 miliseconds. I did this to try and get it triggered twice per frame. Let’s take a look at some results:

Average: 17.17 milliseconds from 100 samples.

Like with the enter frame event, around 2 milliseconds is lost in the event process. Ideally, that number should be about 16 milliseconds, so let’s lower the delay rate down to 14 milliseconds and run the test again.

Average: 16.29 milliseconds from 100 samples.

That’s more like it. Now we have a setup that will be triggered around twice per frame. We can then force the display to be updated after the event is completed by calling 'objTimerEvent.updateAfterEvent()', where 'objTimerEvent' is the name you give the event argument passed to the timer event handler. This will give something like an animation a smoother look while only occuring during the short duration of the animation, as opposed to using the enter frame event with the SWF running at a higher frame rate at all times. It is very important that you do not abuse the use of 'updateAfterEvent'; if it is getting called often and in multiple places, performance will likely take a hit. Having a setup like this centralized in something like an animation manager and then using it throughout your application wisely will result in smoother animations without noticably sacraficing performance.

So, the results of our tests? Both methods perform roughly the same under normal workloads. When you are after smoother animations or need to call something at a given rate other than the framerate, use Timer. However, under heavy loads, both methods become fairly inaccurate, but enter frame seems to be a little less accurate than Timer. Enter frame is nice, convenient, and reliable; I recommend using it for most general tasks.

That’s all for now. I will certainly be doing more and more tests in the weeks to come; I’m anxious to see what I find as I dive deeper into AS3. Feel free to post up comments about this stuff or share your results if you have done similar tests.