jpauclair

In the last posts, I talked about what you can get from mm.cfg setups but I didn’t give any GREAT example of how to use that in an optimization context.
Well here it is:

var a:int = 1;
var b:int = 2;
b = a + a + a;

How could something this simple could be optimized? Can it?
Well yes it can! Not 10% faster… 300% faster!

In fact, Flash is spending precious CPU time working on Numbers data type, assuming that everything can be done with numbers and then converting the whole thing back to int.
If you try to add two Integers, flash will first generate the code as if both var were numbers, and make the float addition with those. But flash (or Jit?) take this code and convert it to a nice int+int operation. This is great, except that the optimization will work only if there is only two operators , not one more!
So b = a+a is pretty fast, but if you had that third “a”, you will be smashed with a nice Number + Number + Number + NumberToInteger operation. This cost A LOT!

Warning: ByteCode AND Assembler ahead!

With mm.cfg, you can get the whole ByteCode with associated Assembler (MIR) in the flashlog when you run a SWF.

The ByteCode

Let’s try some addition variation and generate this with mm.cfg::AS3Verbose=1
Simple addition: In this variation, we add the three vars and make no optimization. Result: two additions of numbers, and one final conversion to int.

 // b = a + a + a;
    25      getlocal1   // get “a”
    26      getlocal1   // get “a” again
    27      add         // Add both int  (no convert_i here)
    28      getlocal1   // get “a”
    29      add         // Add “a” to previous result
    30      convert_i   // Convert the whole result to integer
    31      setlocal2   // Operation is over, save in register

This variation includes a great optimization: Casting the first two elements. It splits the series of addition and let the JIT make its Integer optimization. Drawback is an access to ”findpropstrict” and a call of property. It also hold one more variable in a register but I was not able to determine if this is really a drawback yet.

// b = int(a + a) + a
    25      findpropstrict	int     // find property int (the conversion function)
    27      getlocal1     	        // get “a”
    28      getlocal1     	        // get “a” again
    29      add           	        // Add both int (AS Number?)
    30      callproperty  	int (1) // No number here, use int optimization instead
    33      getlocal1     	        // get i
    34      add           	        // Convert to integer? Optimize: Use integer add.
    35      convert_i     	        // Operation is over, save in register
    36      setlocal2

The last variation is splitting the calculus manually on multiple lines to make sure there is never more than one operation at any time. It forces the JIT to keep int all the way to the end.

// b = a + a
    // b += a
    20      getlocal1   // get “a”
    21      getlocal1   // get “a” again
    22      add         // Add both int
    23      convert_i   // Convert to integer? Optimize: Use integer add.
    24      setlocal2   // Operation 1 is over, save in register
    25      getlocal2   // Start second operation (reload var)
    26      getlocal1   // Prepare addition with “a”
    27      add         // Add both int
    28      convert_i   // Convert to integer? Optimize: Use integer add.
    29      setlocal2   // Operation 2 is over, save in register

The Benchmark

On my computer, using Grant Skinner Performance Test tool:

//Time: 15ms
 b = a + a + a

//Time: 5.8ms
b = int(a + a) + a

//Time: 5ms
b = a + a;
b += a;

The Assembler

How about some assembler now?

// b = a + a + a;
  25:getlocal1
       @77	use   @50 [1]
                        stack: int@77
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@77 int@55 int@59 Number@63
  26:getlocal1
                        stack: int@77 int@77
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@77 int@55 int@59 Number@63
  27:add
       @78	i2d   @77
        	cse   @78
       @79	fadd  @78 @78
                        stack: Number@79
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@77 int@55 int@59 Number@63
  28:getlocal1
                        stack: Number@79 int@77
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@77 int@55 int@59 Number@63
  29:add
        	cse   @78
       @80	fadd  @79 @78
                        stack: Number@80
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@77 int@55 int@59 Number@63
  30:convert_i
       @81	csop  AVMCORE_integer_d_sse2 (@80)
                        stack: int@81
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@77 int@55 int@59 Number@63
  31:setlocal2
                        stack:
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@77 int@81 int@59 Number@63

At the first addition of int, you can see two i2d operations transferring the integers into floats, and then a float addition, giving a “number” result staying on the stack.
Also, there is the final “AVMCORE_integer_d_sse2” which seem to be a great thing (using sse2) optimization, but this cost A LOT! It took almost 9 of the 15ms to process this conversion!

// b = int(a + a) + a
  25:findpropstrict int
       @77	imm   18784736
       @78	imm   18739432
       @79	cmop  MethodEnv::finddefNs (@3, @78, @77)
                        stack: global@79
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@50 int@55 int@59 Number@63
  27:getlocal1
       @81	use   @50 [1]
                        stack: global@79 int@81
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@55 int@59 Number@63
  28:getlocal1
                        stack: global@79 int@81 int@81
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@55 int@59 Number@63
  29:add
       @82	i2d   @81
        	cse   @82
       @83	fadd  @82 @82
                        stack: global@79 Number@83
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@55 int@59 Number@63
  30:callproperty int 1
       @84	add   @81 @81
     	dead   @83
     	dead   @82
     	dead   @82
                        stack: int@84
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@55 int@59 Number@63
  33:getlocal1
                        stack: int@84 int@81
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@55 int@59 Number@63
  34:add
       @85	i2d   @84
       @86	i2d   @81
       @87	fadd  @85 @86
                        stack: Number@87
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@55 int@59 Number@63
  35:convert_i
       @88	add   @84 @81
     	dead   @87
     	dead   @86
     	dead   @85
                        stack: int@88
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@55 int@59 Number@63
  36:setlocal2
                        stack:
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@68
                         locals: tests::Bitwise?@16 int@81 int@88 int@59 Number@63

In this on take a look at the “findpropstrict” which is done in every loop, and then after the first addition there is the “callproperty int” removing in the same time useless float calculus.
This variation keeps the code easy to read. That’s one big advantage!

// b = a + a
    // b += a
  20:getlocal1
       @66	use   @44 [1]
                        stack: int@66
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@49 int@53
  21:getlocal1
                        stack: int@66 int@66
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@49 int@53
  22:add
       @67	i2d   @66
        	cse   @67
       @68	fadd  @67 @67
                        stack: Number@68
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@49 int@53
  23:convert_i
       @69	add   @66 @66
     	dead   @68
     	dead   @67
     	dead   @67
                        stack: int@69
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@49 int@53
  24:setlocal2
                        stack:
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@69 int@53
  25:getlocal2
                        stack: int@69
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@69 int@53
  26:getlocal1
                        stack: int@69 int@66
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@69 int@53
  27:add
       @70	i2d   @69
       @71	i2d   @66
       @72	fadd  @70 @71
                        stack: Number@72
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@69 int@53
  28:convert_i
       @73	add   @69 @66
     	dead   @72
     	dead   @71
     	dead   @70
                        stack: int@73
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@69 int@53
  29:setlocal2
                        stack:
                        scope: [global Object$ flash.events::EventDispatcher$ com.gskinner.performance::TestSuite$ tests::Bitwise$] tests::Bitwise@57
                         locals: tests::Bitwise?@15 int@66 int@73 int@53

This is the fastest variation. Instead of calling anything it just save the current state and let the optimization happen.

    22      add         // Add both int
    23      convert_i   // Convert to integer? Optimize: Use integer add.
    24      setlocal2   // Operation 1 is over, save in register
    25      getlocal2   // Start second operation (reload var)

After each operation, there is the integer optimization, and then a save to local register, followed by the reloading of the same register.
…but the code is a lot less easy to read.

Is this really useful information?

Well for everyday work, I guess not. Still it’s good to know how thing works.
There is some special application that could benefits efforts like 3D rendering engines. Physics engine etc.
For example, in a 3D space where you would like to map a 3 dimensional coordinate into one ByteArray, you could use:

Pos1D = (50 * 50 * z) + (50 * y + x);

And convert this to:

pos1D = 50*50;
pos1D *= z;
pos1D += int(50 * y);
pos1D += x;

The result is the same, except it’s 225% faster. Kinda cool.

Conclusion

I personally consider this as a bug. I hope Adobe (or Tamarin/NanoJIT team?) will fix it in 10.1 (didn’t try the optimization there yet).
But if fixed by Adobe in the next player release, this could mean great optimization for everybody!

Also, some compilers could do that in the background while generating the ByteCode (Yes Nicolas C. I’m talking to you! ).

Also, I did some minor modification in the Base64 Class, I will commit that a bit later but instead of doing “writeInt” I’m using for bytearray[x] instead, this eliminate 3 bitOr and direct access in byte array is a lot faster than using wrinteInt. I gained almost 25% by doing this optimization. I guess I’m now over 1000% faster than AS3Crypto.