Comments on: Loop Speed

By: jackson

jackson — Fri, 10 Jun 2011 16:38:08 +0000

Can’t wait to read that article! :)

By: skyboy

skyboy — Fri, 10 Jun 2011 02:18:10 +0000

I think this is related to my findings of uints being converted to floats in conditionals and brackets (++u; array[u] faster than array[++u]). The problem is entirely the compiler, and it’s strange how Adobe has completely missed these problems.
Also, in a further modified operator speed test I’m going to get around to finishing (1000 operations per loop using Apparat to help. Still a lot of manual work) I noticed that the special opcode for inc/dec Number/int are 2x slower than the 3 op code for get/inc/set and at the same time and, when not used in the above areas, boolean operators are O(1) operations on all numeric datatypes and on all mixtures of numeric datatypes.

By: jackson

jackson — Tue, 07 Jun 2011 17:06:12 +0000

It may be. I'll investigate some more of the int/uint effects. In the meantime, check out my more general article on operator speed. As noted elsewhere, a more focused test on just the < operator is needed to really see the effects of int/uint. Thanks for the tip!

By: erik

erik — Tue, 07 Jun 2011 15:40:49 +0000

I am curious if these findings from WIN 10,3,181,22 are worth considering?

uint < uint 153
int < int 105
int < uint 164
uint < int 142
int < (int)uint 111

It suggests to me that when incrementing through an array/vector, casting vector.length to an int, and also counting up with an int is a worthwhile extra step.

public function intUintShowdown( ):void
{
    super( );
    stage.scaleMode = StageScaleMode.NO_SCALE;
    stage.align = StageAlign.TOP_LEFT;
 
    var logger:TextField = new TextField();
    logger.autoSize = TextFieldAutoSize.LEFT;
    addChild(logger);
    var maxu:uint = 9999 * 5000;
    var maxi:int = 9999 * 5000;
 
    logger.appendText( "maxu: " + maxu + ", maxi: " + maxi + "\n" );
 
    var nowTime:Number = getTimer( );
    for (var u:uint = 0; i &lt; maxu; ++i)
    {
    }
    logger.appendText( &quot;uint &lt; uint\t&quot; + (getTimer()-nowTime) + &quot;\n&quot; );
 
    nowTime = getTimer( );
    for (var i:int = 0; i &lt; maxi; ++i)
    {
    }
    logger.appendText( &quot;int &lt; int\t&quot; + (getTimer()-nowTime) + &quot;\n&quot; );
 
    nowTime = getTimer( );
    for (var i2:int = 0; i2 &lt; maxu; ++i2)
    {
    }
    logger.appendText( &quot;int &lt; uint\t&quot; + (getTimer()-nowTime) + &quot;\n&quot; );
 
    nowTime = getTimer( );
    for (var u2:uint = 0; u2 &lt; maxi; ++u2)
    {
    }
    logger.appendText( &quot;uint &lt; int\t&quot; + (getTimer()-nowTime) + &quot;\n&quot; );
 
 
    nowTime = getTimer( );
    var cmaxi:int = maxu;
    for (var i3:int = 0; i3 &lt; cmaxi; ++i3)
    {
    }
    logger.appendText( &quot;int &lt; (int)uint\t&quot; + (getTimer()-nowTime) + &quot;\n&quot; );
}
}
}

By: jackson

jackson — Wed, 22 Sep 2010 17:16:16 +0000

I opened the test in nemo440 and looked at the bytecode the compiler had generated and it definitely hasn’t optimized any of the test out. Actually, it virtually never optimizes out any of your code. Take this example of both dead code and constant folding I just whipped up:

private function foo(): void
{
    10 + 20;
}

Clearly this does nothing, but here’s what the compiler (MXMLC 4.1) generates:

  function private::foo():void    /* disp_id 0*/
  {
    // local_count=1 max_scope=1 max_stack=2 code_len=9
    0       getlocal0         
    1       pushscope         
    2       pushbyte          10
    4       pushbyte          20
    6       add               
    7       pop               
    8       returnvoid        
  }

As you can see, it didn’t do either optimization.

Still, your results actually don’t differ from mine in the first place, at least if we compensate for CPU speed. Your for loop time is 2.42x slower than your for-each time. If you refer to my Flash Player 10.1 performance update of this article, you’ll see that my for loop time is 2.44x slower than my for-each time.

By: jackson

jackson — Wed, 22 Sep 2010 16:57:01 +0000

I've actually got a two-part series of articles that covers this: Array vs. Vector. In there I explicitly test with different types of elements: int, uint, Number, Boolean, and String. Check it out for the full performance differences as well as the followup article testing performance with Flash Player 10.1.

By: jardilio

jardilio — Wed, 22 Sep 2010 15:50:27 +0000

A friend just referred me to this page and I think that the test scenario in play here is getting optimized by the compiler as you are not really doing anything with the values in the array for the for loop case. I condensed your test to just working with the for and for each for an array and the only thing I modified was change “a = ?” to “a += ?”. I ended up getting very different results where the foreach was actually much faster. I think what was happening in your test case was that the value from the array was not actually getting retrieved in the for loop as it was getting optimized by the compiler.

const SIZE:uint = 6000;
const REPS:uint = 2000;
 
var i:int;
var s:String;
var a:int = 0;
var b:String;
var rep:int;
var res:String = "For-each times:\n";
var before:uint;
var after:uint;
var arr:Array = new Array(SIZE);
 
for (i = 0; i < SIZE; ++i)
{
    arr[i] = int(Math.random()*1000);
}
 
before = getTimer();
for (rep = 0; rep < REPS; ++rep)
{
    for each (i in arr)
    {
        a += i;
    }
}
after = getTimer();
res += "\tArray: " + (after-before) + "\n";
 
res += "For times:\n";
 
a = 0;
 
before = getTimer();
for (rep = 0; rep < REPS; ++rep)
{
    for (i = 0; i < SIZE; ++i)
    {
        a += arr[i];
    }
}
after = getTimer();
res += "\tArray: " + (after-before) + "\n";
 
trace(res);

For-each times:
    Array: 2603
For times:
    Array: 6313

By: jwopitz

jwopitz — Wed, 22 Sep 2010 15:39:54 +0000

Sorry the Vector type brackets didn’t show. I meant:

Vector (ComplexObject)

Vector (int or String or other simple types)

By: jwopitz

jwopitz — Wed, 22 Sep 2010 15:38:07 +0000

Have you found any performance drop when using complex object types for the Vectors. I can’t remember where I heard this but accessing the following:

for.. Vector

is much slower than

for.. Vector

By: Li

Li — Fri, 09 Oct 2009 00:18:28 +0000

Excellent test. I’ve seen similar ones but this is so clear and effective. Thanks!