AS3 is FAST!

I'm usually the one complaining about ActionScript performance but I have to give credit where it's due. AS3 is just plain fast.

I'd been kicking around some AS3 ideas I had and ran into some pretty nifty performance tricks. You can see them in action at the URL below - (open it full screen as the swf is 1024x768 - no wimpy resolutions for this!):

http://www.electrotank.com/junk/mike/flash/objectpool/

The controls on the left are simple.
Frames -how many frames to run the simulation.
Arrows per frame - how many arrows are to be generated per each frame.
Use pool - should the object pool be used for this simulation run.
Start - start the simulation, turns to stop when the simulation is running.

The stats on the right are a little trickier.
Arrows - the number of arrows currently on the screen.
Render - how many milliseconds the enterFrame event has taken to process.
Total Arrows - the number of arrows used in the simulation thus far.
Total Render - how many milliseconds for all the enterFrame calls in the simulation.

A combination of tricks were used to make it perform as well as it does.

1) Sprite sheets + scrollrect
This is the same trick VengenceMX is using for his Invasion game. In fact, I'm using his sprite sheet (thanks!). Basically, to handle an object + rotation, you simply have a sheet of images that contains all rotations/angles in a row. Then a little math is used to determine which image of the strip is to be shown. You then use scrollrect to show just that image. Think of it like a film strip you can slide back and forth to see only the image you want.


2) Object pooling
Object pooling is the process of storing objects in a pool when they are not in use so as to avoid the overhead of creating them again and again. In AS3, objects that are tied to the library are expensive to create. By storing them in a pool for later use you can greatly reduce memory usage and save a handful of milliseconds every frame.

To see the pooling in action, simply run the simulation with "use pool" checked and note the "total render" time. Then run it again with out and note the difference. The results vary quite a bit but pooling is always faster. Some times it can be as much as 2x faster. In short, pooling burns less time per frame to create the sprites. The effect is even larger with movie clips. You might not see this as a frame rate increase but it still gives you more time to do code that matters (like AI or pathfinding).

One other subtle difference occurs with pooling. You can see a slight "jerkiness" to the simulation if pooling is off. The "jerks" will occur every 1/2 - 1 second or so. I'm reasonably sure they are caused by garbage collection runs inside the Flash VM. Pooling uses a great deal less overall memory and so it experiences a lot less garbage collection all around - ie. smoother animation. This is really visible in scrolling tiles.

3) Utilizing the scene graph arrays
This is simple, but all the little bits count. I needed to store a collection of arrows so I could iterate over them each enter-frame. Traditionally, I'd create an array of arrows to do this. In AS3 though, there is no need. If you simply create a new empty sprite, and add it as a child to the stage, you have your array already.

Anything added as a child can be retrieved and accessed easily. For instance, with my arrows, I had some code that looked like this:

for(var i:int = 0; i < arrows.numChildren; i++) ...

That's it. That gives me my array already with no extra overhead. As I said, not a big deal, but the less work you do per frame the better.

I'll be posting a lot more detail on points one and two in the next day or so. My object pooling code is actually a generic framework that works great as it is and can be dropped into any AS3 project without too much trouble. Have fun!