I'd take these results with a pinch of salt. I don't think they're
conclusive, since one test seems to affect the performance of the others
(and we are talking about really small differences anyway, which I think
could be attributed to other factors than the tested code itself).
Let's take, for instance the for / while tests. If I run all your tests, I
get results similar to yours.
takeLengthPlusOut : 1958
takeForWithLengthPlus : 1788
However, if I run just those two tests the results change. And if I alter
the order in which the tests are run, the first one always seems to take
less time.
// running just these two, tracing the results in the same order the loops
are executed
takeLengthPlusOut : 1876
takeForWithLengthPlus : 2003
takeLengthPlusOut : 1876
takeForWithLengthPlus : 1935
takeForWithLengthPlus : 1874
takeLengthPlusOut : 1946
takeForWithLengthPlus : 1861
takeLengthPlusOut : 1935
I think this particular for / while case is very illustrative of some
external bias, because the execution order consistently affects the results
and because if you disassemble both loops, they're nearly identical. The
only difference is the order in which one operation previous to the loop is
executed (it's not even the "body" of the loop or its conditional test).
FOR:
function takeForWithLengthPlus():String /* disp_id 0*/
{
// local_count=4 max_scope=1 max_stack=3 code_len=61
0 getlocal0
1 pushscope
2 pushbyte 0
4 setlocal1
5 pushnull
6 coerce Array
8 setlocal2
9 pushnan
10 setlocal3
11 findpropstrict Array
13 constructprop Array (0)
16 coerce Array
18 setlocal2
19 findpropstrict flash.utils::getTimer
21 callproperty flash.utils::getTimer (0)
24 convert_d
25 setlocal3
26 pushbyte 0
28 setlocal1
29 jump L1
L2:
33 label
34 getlocal2
35 getlocal2
36 getproperty length
38 getlocal1
39 setproperty null
41 inclocal_i 1
L1:
43 getlocal1
44 pushint 10000000 // 0x989680
46 iflt L2
50 pushstring "takeForWithLengthPlus : "
52 findpropstrict flash.utils::getTimer
54 callproperty flash.utils::getTimer (0)
57 getlocal3
58 subtract
59 add
60 returnvalue
}
WHILE:
function takeLengthPlusOut():String /* disp_id 0*/
{
// local_count=4 max_scope=1 max_stack=3 code_len=61
0 getlocal0
1 pushscope
2 pushbyte 0
4 setlocal1
5 pushnull
6 coerce Array
8 setlocal2
9 pushnan
10 setlocal3
11 pushbyte 0
13 setlocal1
14 findpropstrict Array
16 constructprop Array (0)
19 coerce Array
21 setlocal2
22 findpropstrict flash.utils::getTimer
24 callproperty flash.utils::getTimer (0)
27 convert_d
28 setlocal3
29 jump L1
L2:
33 label
34 getlocal2
35 getlocal2
36 getproperty length
38 getlocal1
39 setproperty null
41 inclocal_i 1
L1:
43 getlocal1
44 pushint 10000000 // 0x989680
46 iflt L2
50 pushstring "takeLengthPlusOut : "
52 findpropstrict flash.utils::getTimer
54 callproperty flash.utils::getTimer (0)
57 getlocal3
58 subtract
59 add
60 returnvalue
}
The only difference is that in the foor loop, i = 0 is run immediately
before testing i against 10000000:
26 pushbyte 0
28 setlocal1
whereas in the while loop, that assignment is executed before constructing
the array:
11 pushbyte 0
13 setlocal1
Cheers
Juan Pablo Califano
2008/7/29, laurent <[EMAIL PROTECTED]>:
>
> Hi,
>
> I often asked myself if a[ a.length ] = xxx was faster or slower then
> a.push( xxx ), I did some test at wake up, fresh with coffee.
> So now I know the answer and I got a bit more about while and for, and more
> obvious about using them with decremental or incremental counters.
>
> from results, > means faster :
>
> for > while ....hey yes...oO
> increment > decrement
> length > push
> increment or certainly make any number operation at same time than putting
> the value in variable is slower than separate those actions, like:
> a[ a.length ] = i++;
> slower than:
> i++;
> a[ a.length ] = i;
>
> "while incremental" is faster than "for decremental".
> This is a totaly useless information as if you can use the while
> incremental instead of For decremental, then just use For incremental.
> I heard that any loop was compiled to a while loop so I started coding
> everything with a while, what is faster to write and more elegant.
> Now I'll go back to those For loops, I promess I never stoped loving you
> guys...
>
> here some convincing results :
> takeLengthMinus : 1695
> takeLengthMinusOut : 1598
> takeLengthPlus : 1580
> takeLengthPlusOut : 1550
>
>
> takePushMinus : 1860
> takePushMinusOut : 1768
> takePushPlus : 1756
> takePushPlusOut : 1685
>
> Don't compare results between separate paragraphe because they did not run
> all together:
>
> takeForWithLengthMinus : 1624
> takeForWithLengthPlus : 1581
>
> The For loop is directly with operation outside, so it has to be compared
> to the
>
> other outside operations:
>
> takeLengthMinusOut : 1686
> takeLengthPlusOut : 1610
> takePushMinusOut : 1788
> takePushPlusOut : 1666
> takeForWithLengthMinus : 1626
> takeForWithLengthPlus : 1563
>
> I guess that's why I learned to use for( i = 0; i < n; i++ ) for my first
> loops.
> So if we want our code faster we have to make it longer and actually more
> human readable, at the same time it means more computer readable as it gets
> faster....hm, is the computer so close to human...?!
>
> I [ mean my brain ] actually use a dicotomic way to find my current client
> folder in the list of all my works.
>
> cheers.
> L
>
> and here the codes :
>
>
> function takeLengthMinus():String{
> var i : int = 10000000;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i-- ){
> a[ a.length ] = i;
> }
> return "takeLengthMinus : " + ( getTimer() - t );
> }
>
> function takeLengthMinusOut():String{
> var i : int = 10000000;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i ){
> a[ a.length ] = i;
> i--;
> }
> return "takeLengthMinusOut : " + ( getTimer() - t );
> }
>
> function takeLengthPlus():String{
> var i : int = 0;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i < 10000000 ){
> a[ a.length ] = i++;
> }
> return "takeLengthPlus : " + ( getTimer() - t );
> }
>
> function takeLengthPlusOut():String{
> var i : int = 0;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i < 10000000 ){
> a[ a.length ] = i;
> i++;
> }
> return "takeLengthPlusOut : " + ( getTimer() - t );
> }
>
> function takePushMinus():String{
> var i : int = 10000000;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i-- ){
> a.push( i );
> }
> return "takePushMinus : " + ( getTimer() - t );
> }
>
> function takePushMinusOut():String{
> var i : int = 10000000;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i ){
> i--;
> a.push( i );
> }
> return "takePushMinusOut : " + ( getTimer() - t );
> }
>
> function takePushPlus():String{
> var i : int = 0;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i < 10000000 ){
> a.push( i++ );
> }
> return "takePushPlus : " + ( getTimer() - t );
> }
>
> function takePushPlusOut():String{
> var i : int = 0;
> var a: Array = new Array();
> var t: Number = getTimer();
> while( i < 10000000 ){
> a.push( i );
> i++;
> }
> return "takePushPlusOut : " + ( getTimer() - t );
> }
>
> function takeForWithLengthMinus():String{
> var i : int;
> var a: Array = new Array();
> var t: Number = getTimer();
> for( i = 10000000; i > 0; i-- ){
> a[ a.length ] = i;
> }
> return "takeForWithLengthMinus : " + ( getTimer() - t );
> }
>
> function takeForWithLengthPlus():String{
> var i : int;
> var a: Array = new Array();
> var t: Number = getTimer();
> for( i = 0; i < 10000000; i++ ){
> a[ a.length ] = i;
> }
> return "takeForWithLengthPlus : " + ( getTimer() - t );
> }
>
> //trace( takeLengthMinus() );
> trace( takeLengthMinusOut() );
> //trace( takeLengthPlus() );
> trace( takeLengthPlusOut() );
> //trace( takePushMinus() );
> trace( takePushMinusOut() );
> //trace( takePushPlus() );
> trace( takePushPlusOut() );
> trace( takeForWithLengthMinus() );
> trace( takeForWithLengthPlus() );
>
> _______________________________________________
> Flashcoders mailing list
> Flashcoders@chattyfig.figleaf.com
> http://chattyfig.figleaf.com/mailman/listinfo/flashcoders
>
_______________________________________________
Flashcoders mailing list
Flashcoders@chattyfig.figleaf.com
http://chattyfig.figleaf.com/mailman/listinfo/flashcoders
