AS3 Speed tests

This is a community maintained page of speed optimization techniques for use with ActionScript3. Originally started on RockOnFlash.com, the post just grew with new revisions and tests and yet new techniques from the community! Only made sense to put it on a wiki for everyone to maintain ;)

General Notes

(Morf) Many of these enhancements are particular to the type of variable declaration you use. So far, in testing Number vs. int, the greatest improvements are gained when using ints. In general (with exceptions), only moderate if any improvements are seen when using Number-declared variables, due to the limited accurate operations.

The following excellent generalizations come from Andre Michelle’s website (link below):

- Do not overload condition and statements as in AS2

It astounds me that this once-excellent technique for optimizing for speed no produces faster code. Overloading *should* produce faster code by reducing the number of compiled instructions and generating faster ones.

- Do not use Objects, if you know which properties will be finally involved.

- Cast instances, while reading from an Array

- Try to use Integers (int) for all possible cases

- Bitoperators are lightning fast

(Other things we what would like to see in AS3:

- Typed, length-fixed Arrays.

“…this would increase the speed…”

- A faster solution to read/write pixels on a bitmap.)

Optimization Links

Dennis Ippel - Some ActionScript 3.0 Optimizations and links

Andre Michelle - General Guidelines for AS3 Optimizations

Integer Addition & Increment/Decrement

Tests done to determine if “a += b” really is faster (as it should be) than “a = a + b” have been inconclusive so far. I’d still recommend using the shorthand if you’re accustomed to it, mostly because I’m hoping a new compiler will grant faster speeds for using it.

The good news is that Incrementing (adding 1) with the ++ operator is far faster than “a = a + 1” - in fast, using the ++ four times (in consecutive statements) is still about 50% faster than “a = a + 4”!!

Unfortunately, the same is not true with the decrement (–) operator. So far, tests on that have not shown any consistent speed increase over “a = a - 1”. (sigh)

Here’s the testing code:

import flash.utils.getTimer;

var time: Number = getTimer();
var sumStd: Number = 0;
var sumOpt: Number = 0;
var sumMpt: Number = 0;
var loops: Number;
var thresh: Number = 0.002;


function runStdTest():void {
time = getTimer();
for (var i:int = 0; i < 20000000; i++) {
var test:int = i;
test = test - 1;
}
sumStd += (getTimer() - time);
}


function runOptTest():void {
time = getTimer();
for (var i:int = 0; i < 20000000; i++) {
var test:int = i;
test--;
}
sumOpt += (getTimer() - time);
}


function runEmptyTest():void {
time = getTimer();
for (var i:int = 0; i < 20000000; i++) {
var test:int = i;
}
sumMpt += (getTimer() - time);
}



loops = 10;
for (var i:int = 0; i < loops; i++) {
runStdTest();
runOptTest();
runEmptyTest();
}

trace ("Standard vs. Optimization - Mean over", loops, "loops");
trace ("Standard Test: ", (sumStd /= loops));
trace();

Division

divide by 2

Now, you’ve probably heard the tip about “use multiplication instead of division when dividing by 2”, right?

faster:

var n:Number = value *.5;

slower:

var n:Number = value / 2;

run it with a test:

import flash.utils.getTimer;

var time:Number = getTimer();

function runDivisionTest():void
{
time = getTimer();
for(var i:int=0;i<10000000;i++) 
{
var test:Number = i/2;
}
trace("DivisionTest: ", (getTimer()-time));
}

function runMultTest():void
{
time = getTimer();
for(var i:int=0;i<10000000;i++) 
{
var test:Number = i*.5;
}
trace("MultTest: ", (getTimer()-time));
}
runDivisionTest();
runMultTest();

traces out:

DivisionTest:  162
MultTest:  110

Alright, so it’s not miles faster, but in a 3D engine like Papervision3D, this becomes the difference between a fast engine and a slow engine real quickly.

Well, there’s one still that’s even faster: Bitwise shift operations

Divide by 2 with a right shift:

trace(10 >> 1);
// traces:
5

Multiply by 2 with a left shift:

trace(10 << 1);
// traces:
20

Now, run the test against the Division and Multiplication tests above:

function runBitTest():void
{
time = getTimer();
for(var i:int=0;i<10000000;i++) 
{
var test:int = i >> 1;
}
trace("BitTest: ", (getTimer()-time));
}
runBitTest();

traces out:

DivisionTest:  152
MultTest:  112
BitTest:  63

HOLY CRAP Batman - that’s nearly 1/2 the speed?? or should I say, 1*.5 the speed ;)

(Morf) Well, kind of - but you may not want to use the bitshift. When the BitTest code above uses the the same (slower) Number declaration for test, the results are slightly different (btw, the iterator i in each testing loop also now has the same declaration (int) in each code section ):

Division by 2 - Mean over 20 loops
DivisionTest:  83.3
MultTest:  62.9
BitRightTest:  45.85
EmptyCodeTest:  29.1

I’ve also thrown in an empty loop timing for comparison - so a more accurate comparison can be made by subtracting that timing from each of the others. These gave:

Net timing results:
DivisionTest:  54.2
MultTest:  33.8
BitRightTest:  16.75

So both optimizations are still faster with Number declarations. But don’t use BitShifting for Number operations. That’s because the bit shift will round off the result to an integer - AS3 turns your original value into an integer before making the bit shift. Unless that’s what you’re after, use “0.5 *” instead.

Math.floor/Math.ceil

So, I was looking at some other stuff with uint and this seems to be a real gem when it comes to Math.floor and Math.ceil operations. I was reading through Flash’s help (I have to say, I really enjoy the new help - I live in there) on uint and realized that, like int, when you pass a number, it strips everything passed the decimal (like Math.floor). So, I thought, what the hey, let’s give er’ a speed test.

Sure enough, it was much faster to use uint(n) than Math.floor(n) - nearly 10x’s as fast

– UPDATE – After Paulius Uza’s comments about using int, I went back and added tests for int with the floor/ceil tests, and sure enough, they’re even faster than using uint. floor’s test wasn’t that drastic, but ceil’s was 1/2 the time of uint’s version

– /UPDATE –

fast:

var test:int = int(1.5);
//test equals 1

slow:

var test:Number = Math.floor(1.5);
//test equals 1

– /UPDATE by lilive –

But take care, this solution is only for positive integer:

var test1:int = int(-1.5);
//test1 equals -1
var test2:Number = Math.floor(-1.5);
//test2 equals -2

Now, I know what yer thinkin’: what about Math.ceil? +1? yes ;)

– /UPDATE by matthewwithanm – Note that this this is not a general replacement for ceil as it will give an incorrect result for integers. [ceil(1) == 1 but int(1) + 1 == 2]

fast:

var test:int = int(1.5)+1;
//test equals 2

slow:

var test:Number = Math.ceil(1.5);
//test equals 2

Time for a test:

function runFloorTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++)
{
var n:Number = 1.5;
var test:Number = Math.floor(n);
}
trace("FloorTest: ", (getTimer()-time));
}
function runUintFloorTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++)
{
var n:Number = 1.5;
var test:uint = uint(n);
}
trace("UintFloorTest: ", (getTimer()-time));
}
function runIntFloorTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++)
{
var n:Number = 1.5;
var test:int = int(n);
}
trace("IntFloorTest: ", (getTimer()-time));
}
function runCeilTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++)
{
var n:Number = 1.5;
var test:Number = Math.ceil(n);
}
trace("CeilTest: ", (getTimer()-time));
}
function runUintCeilTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++)
{
var n:Number = 1.5;
var test:uint = n == uint(n) ? n : uint(n)+1;
}
trace("UintCeilTest: ", (getTimer()-time));
}
function runIntCeilTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++)
{
var n:Number = 1.5;
var test:int = n == int(n) ? n : int(n)+1;
}
trace("IntCeilTest: ", (getTimer()-time));
}
function runBitShiftFloorTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++)
{
var n:Number = 1.5;
var test:Number = n >> 0;
}
trace("BitShiftFloorTest: ", (getTimer()-time));
}
runFloorTest();
runUintFloorTest();
runIntFloorTest();
runBitShiftFloorTest();
runUintCeilTest();
runIntCeilTest();

traces out:

FloorTest:  1733
UintFloorTest:  176
*IntFloorTest:  157
BitShiftFloorTest:  178
UintCeilTest:  650
*IntCeilTest:  384

Math.abs

I was thinking about another one that I use sometimes which was using *-1 instead of Math.abs on a number

faster:

var nn:Number = -23
var test:Number= nn < 0 ? nn * -1 : nn;

slower:

var nn:Number = -23
var test:Number = Math.abs(nn);

Lets test!

function runABSTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++) 
{
var n:Number = -1.5;
var test:Number = Math.abs(n);
}
trace("ABSTest: ", (getTimer()-time));
}

function runABSMultTest():void
{
time = getTimer();
for(var i:uint=0;i<10000000;i++) 
{
var n:Number = -1.5;
var test:Number = n < 0 ? n * -1 : n;
}
trace("ABSMultTest: ", (getTimer()-time));
}
runABSTest();
runABSMultTest();

traces out:

ABSTest:  1615
*ABSMultTest:  153

(Morf) So... Taking this a bit further, instead of multiplying by -1, what about just assigning the inverse? The code is updated so n (instead of test) receives the new Abs value:

function runAbsTest():void  {
time = getTimer();
for (var i:int = 0; i < 10000000; i++)  {
var n:Number = -1.5;
n = Math.abs (n);
}
sumAbs += (getTimer() - time);
}

function runMm1Test():void  {
time = getTimer();
for (var i:int = 0; i < 10000000; i++)  {
var n:Number = -1.5;
n = n < 0 ? n * -1 : n;
}
sumMm1 += (getTimer() - time);
}

function runChsTest():void  {
time = getTimer();
for (var i:int = 0; i < 10000000; i++)  {
var n:Number = -1.5;
n = n < 0 ? -n : n;
}
sumChs += (getTimer() - time);
}

function runEmptyTest():void  {
time = getTimer();
for (var i:int = 0; i < 10000000; i++)  {
var n:Number = -1.5;
n = n;
}
sumMpt += (getTimer() - time);
}

And what if we just tested to see if n was less than zero before doing anything?

function runIfmTest():void  {
time = getTimer();
for (var i:int = 0; i < 10000000; i++)  {
var n:Number = -1.5;
if (n < 0)  n = -n;
}
sumIfm += (getTimer() - time);
}

Traced out:

Abs - Mean over 25 loops
AbsTest:  1572.4
MultByMinus1Test:  121.96
ChsTest:  95.76
IfMinusTest:  76
EmptyTest:  32.48

Net timing results:
AbsTest:  1539.92
MultByMinus1Test:  89.48
ChsTest:  63.28
IfMinusTest:  43.52

Bear in mind the IfMinusTest code assumes the inverse operation must take place every time (n is always < 0) - so the actual implementation would probably run even faster.

Math.sqrt

In response to a question posted on how to determine distance, someone said “sqrt is an expensive operation”. So I tried it out against the old Babylonian Method that was known (as recently as the late 20th century !) to be quite accurate once you’d run it through a few iterations:

import flash.utils.getTimer;
 
var time: Number = getTimer();
var sumSqrt: Number = 0;
var sumAppr: Number = 0;
var sumMpt: Number = 0;
var loops: Number;

var thresh: Number = 0.00001;
var a: Number = 0,
b: Number = 0,
c: Number = 0,
w: Number = 0;

var count: int = 0;

w = 147.29;
trace ("Actual value =", Math.sqrt (w));// This is what AS3 gives us.
trace ("Testing threshold:", thresh);

b = w * 0.25;
do {
count++;
c = w / b;
b = (b + c) * 0.5;
a = b - c;
if (a < 0)  a = -a;
} while (a > thresh);// This tests the algorithm.

c = Math.sqrt (w);
trace ("Number of iterations for approximation:", count);
trace ("Approximation:", b);
trace ("Error in approximation:", b - Math.sqrt (w));
trace (" - - - -");

function runSqrtTest():void  {
time = getTimer();
for (var i:int = 0; i < 1000000; i++)  {
var test:Number = Math.sqrt (w);
}
sumSqrt += (getTimer() - time);
}


function runApprTest():void  {
time = getTimer();
for (var i:int = 0; i < 1000000; i++)  {
var b:Number = w * 0.25,
a:Number;
c:Number;
do {
c = w / b;
b = (b + c) * 0.5;
a = b - c;
if (a < 0)  a = -a;
} while (a > thresh);
}
sumAppr += (getTimer() - time);
}


function runEmptyTest():void  {
time = getTimer();
for (var i:int = 0; i < 1000000; i++)  {
var n:Number = w;
}
sumMpt += (getTimer() - time);
}


loops = 20;
for (var i:int = 0; i < loops; i++)  {
runSqrtTest();
runApprTest();
runEmptyTest();
}

trace ("Math.sqrt - Mean over", loops, "loops");
trace ("Math.sqrt() Test: ", (sumSqrt /= loops));
trace ("Approximation Test: ", (sumAppr /= loops));
trace ("Empty Test: ", (sumMpt /= loops));

trace ("Net timing results:");
trace ("Math.sqrt() Test:", (sumSqrt - sumMpt));
trace ("Approximation Test:", (sumAppr - sumMpt));

I could not believe the results:

Actual value = 12.136309158883519
Testing threshold: 0.00001
Number of iterations for approximation: 6
Approximation: 12.13630915888352
Error in approximation: 1.7763568394002505e-15
 - - - -
Math.sqrt - Mean over 20 loops
Math.sqrt() Test:  172.05
Approximation Test:  134.8
Empty Test:  4.05
Net timing results:
Math.sqrt() Test: 168
Approximation Test: 130.75

Okay, what gives? Even my math co-processor on my old 286 (that I still do my taxes on) could do better than that! And when we boost the testing threshold up for one less iteration, we still get 10-digit accuracy, but with nearly a 1/3 speed boost:

Actual value = 12.136309158883519
Testing threshold: 0.002
Number of iterations for approximation: 5
Approximation: 12.136309166280597
Error in approximation: 7.397078505277932e-9
 - - - -
Math.sqrt - Mean over 20 loops
Math.sqrt() Test:  167.3
Approximation Test:  114.95
Empty Test:  3.95
Net timing results:
Math.sqrt() Test: 163.35000000000002
Approximation Test: 111
Speed Increase:   32.047750229568415 %

I can’t help feeling like I’m missing something here :T

If I’m not, then this algorithm will be faster than Math.sqrt.

UPDATE by [e-mail]: Whoever posted this tip must’ve used an older version of Flash. I ran the Math.sqrt improvement test with Flash 9 v. 115 today on March 26th, 2008. The results were the opposite. I think Adobe optimized their Math.sqrt. Here are the results I got when running your code:

Actual value = 12.136309158883519
Testing threshold: 0.00001
Number of iterations for approximation: 6
Approximation: 12.13630915888352
Error in approximation: 1.7763568394002505e-15
 - - - -
Math.sqrt - Mean over 20 loops
Math.sqrt() Test:  36.65
Approximation Test:  60.1
Empty Test:  26.8
Net timing results:
Math.sqrt() Test: 9.849999999999998
Approximation Test: 33.3

(Morf) UPDATE RESPONSE: That revision of Flash did speed a lot of things up, including Math.sqrt(); I suspect they streamlined calls in general (this process is by far the biggest culprit in this problem). I did go ahead and create faster code that is way way uglier. It is faster by about 20% under Flash 10... but only gives approx .0001 accuracy, which is plenty for Papervision3D applications. In any case, I don’t recommend its use as it will not offer any increase in speed unless used inline (not as any sort of function or method).

Here’s the package used for testing:

package
{
import flash.display.*;
import flash.text.*;
import flash.utils.getTimer;

public class Main extends Sprite
{
public function Main()
{
var time: Number = getTimer();
var sumSqrt: Number = 0;
var sumAppr: Number = 0;
var sumMpt: Number = 0;
var loops: Number;
var resultMsg:TextField = new TextField();
addChild (resultMsg);

var thresh: Number = 0.002;
var a: Number = 0,
b: Number = 0,
c: Number = 0,
ww: Number = 0,
www: Number = 0;

var count: int = 0;
var j: int = 0;
var jj: int = 0;

function runApprTest():void
{
time = getTimer();
for (var ii:int = 0; ii < 20; ii++)  {
for (var i:int = 33000; i < 44000; i++)  {
var sqNum:Number = i + 0.208;


//--Using the Babylonian Method for computing square roots efficiently requires making the initial fast
// approximation as accurate as possible, insuring that the number of iterations can be minimized while
// perserving a desired level of accuracy.
//
var apprxInit: int;
var apprxRoot: Number;
var initVal: Number;
var invVal: Boolean;

if (sqNum < 1) {
initVal = 1 / sqNum;
invVal = true;
} else {
initVal = sqNum;
invVal = false;
}
apprxInit = initVal;

//--Make first approximation of APPRXROOT:  Set the starting approximation APPRXINIT to determine
// its binary degree; in this case, the location of its most significant bit to determine its length
// in bits.
//  In AS3, the most efficient method for accomplishing this is by comparing it to integers equal to odd
// powers of 2, then shifting it right half the number of bits of its length.  This unfortunately results
// in rather unseemly code.  The final treatment is one iteration of the Babylonian Method.  "Hey, Morf
// said it's fast and it works"
//   Well, yes... but this MUST BE USED AS INLINE CODE FOR ANY SPEED OPTIMIZATION TO BE REALIZED.
//
if (apprxInit > 7) {
if (apprxInit < 32768) {
if (apprxInit < 128) {
if (apprxInit < 32) {
apprxInit >>= 2;
if (apprxInit < 4) apprxInit++;
} else {
apprxInit >>= 3;
}
} else {
if (apprxInit < 2048) {
if (apprxInit < 512) {
apprxInit >>= 4;
} else {
apprxInit >>= 5;
}
} else {
if (apprxInit < 8096) {
apprxInit >>= 6;
} else {
apprxInit >>= 7;
}
}
}
} else {
if (apprxInit < 8388608) {
if (apprxInit < 524288) {
if (apprxInit < 131072) {
apprxInit >>= 8;
} else {
apprxInit >>= 9;
}
} else {
if (apprxInit < 2097152) {
apprxInit >>= 10;
} else {
apprxInit >>= 11;
}
}
} else {
if (apprxInit < 134217728) {
if (apprxInit < 33554432) {
apprxInit >>= 12;
} else {
apprxInit >>= 13;
}
} else {
apprxInit >>= 14;//What are you doing with a number this big anyway?  Not bothering with yet another test.
}
}
}
apprxRoot = (apprxInit + initVal / apprxInit) * 0.5;
} else if (apprxInit < 2)  apprxRoot = initVal * 0.5 + 0.5
else apprxRoot = initVal * 0.25 + 1;
//
//-- First approximation will be within about 1% at twice the speed and may be sufficient for collision detection computations.

//-- Now perform as many additional approximations as desired; fourth iteration = same precision as Math.sqrt().
//
apprxRoot = (apprxRoot + initVal / apprxRoot) * 0.5;// babylonian iteration 2 -- about 20% faster.
//apprxRoot = (apprxRoot + initVal / apprxRoot) * 0.5;// babylonian iteration 3 -- seven-digit precision.
//apprxRoot = (apprxRoot + initVal / apprxRoot) * 0.5;// babylonian iteration 4 -- full precision.

if (invVal)  apprxRoot = 1 / apprxRoot;

}
}
sumAppr += (getTimer() - time);
}


function runSqrtTest():void
{
time = getTimer();
for (var ii:int = 0; ii < 20; ii++)  {
for (var i:int = 33000; i < 44000; i++)  {
var w:Number = i + 0.208;
var test:Number = Math.sqrt (w);
}
}
sumSqrt += (getTimer() - time);
}


function runEmptyTest():void  {
time = getTimer();
for (var ii:int = 0; ii < 20; ii++)  {
for (var i:int = 33000; i < 44000; i++)  {
var n:Number = i + 0.208;
}}
sumMpt += (getTimer() - time);
}


loops = 50;
for (var i:int = 0; i < loops; i++)  {
runSqrtTest();
runApprTest();
runEmptyTest();
}

resultMsg.text = "Math.sqrt - Mean over " + loops + " loops" 
+ "/n" + "Math.sqrt() Test:  " + (sumSqrt /= loops) 
+ "/n" + "Approximation Test:  " + (sumAppr /= loops) 
+ "/n" + "Empty Test:  " + (sumMpt /= loops) 
+ "/n" + "Net timing results:" 
+ "/n" + "Math.sqrt() Test:  " + (sumSqrt - sumMpt) 
+ "/n" + "Approximation Test:  " + (sumAppr - sumMpt) 
+ "/n" + "Speed Increase:   " + 100 * (sumSqrt - sumAppr) / (sumSqrt - sumMpt) + "%  (anecdotal)";
resultMsg.autoSize = TextFieldAutoSize.LEFT;
}
}
}