Optimization

2017-06-05T09:26:39Z

Anima: "moveq.l" always sign extent the byte value to a long.

As seen on the [[68k instructions timings]].

=VRAM access=

Since <pre>move.w *,xxx.L</pre>
Is always slower than <pre>move.w *,d(An)</pre>
Try reserving an address register to hold {{Reg|VRAM_ADDR}} and add offsets to access {{Reg|VRAM_RW}} and {{Reg|VRAM_MOD}}. But be careful about [[VRAM]] timings !

<syntaxhighlight>
lea VRAM_RW,a5
move.w #$0001,2(a5) ; VRAM_MOD
...
move.w #$1234,-2(a5) ; VRAM_ADDR
...
move.w #$5678,(a5) ; VRAM_RW
</syntaxhighlight>

=General 68k tricks=

Many tricks are from [[http://www.easy68k.com/ Easy68k]].

==Adressing==

* (An)+ is faster than -(An), except for MOVEs (same).
* Because (An) is faster without pre-dec/post-inc, access to the first element of a data structure is faster than to the others.
* Don't assume that long operations are always slower than word-size ones. For instance, word address operations can be slower than long ones because of the time to sign-extend a word value.

==CALL/RTS with JMP==

<pre>
lea return, A0
jmp routine
return:
</pre>
Then to return, just jmp (A0). A0 Needs to be preserved but saves 8 cycles compared to call/rts.

==Replace JSR+RTS==
<pre>
jsr subroutine -> jmp subroutine ; Saves 24 cycles
rts
</pre>

==Replace JSR+JMP==
Instead of:
<pre>
jsr sub ; 18/20
jmp next ; 10/12
</pre>
Do:
<pre>
pea next ; 16/20
jmp sub ; 10/12
</pre>

==Comparisons==
cmp.l #xxx,Dn takes 14 cycles. If the value being tested for is small enough to fit in a moveq (-128 to +127), it's shorter and faster to put the value in a temporary register:

<pre>
moveq.l #xxx,d0
cmp.l d0,d1
</pre>

If the value xxx is between -8 and 8, and you don't mind altering the data register, you can just use subq #xxx,Dn (or addq) instead of cmp. Then you can use a conditional branch just as you would after a cmp. This works for word or longword comparisons.

==Loops/searches==
Since a taken short branch is slower than an untaken one, try to avoid taking most branches. For instance, if you have a loop searching for a null, the simple way to search is:

<pre>
-:
tst.b (a0)+
bne.s -
</pre>

It takes only a bit more space to unroll one or more iterations of the loop:

<pre>
-:
tst.b (a0)+
beq.s found
tst.b (a0)+
bne.s -
found:
</pre>

==Clear data register==
<pre>
clr.l Dn -> moveq.l #0,Dn ; Saves 2 cycles
</pre>

==Clear address register==
There are no CLR or MOVEQ for address registers.
<pre>
move.l #0,An -> sub.l An,An ; Saves 4 cycles
</pre>

==Clear upper half of data register==
<pre>
andi.l #$0000FFFF,Dn -> swap Dn ; Saves 4 cycles
clr.w Dn
swap Dn
</pre>

==Set large constants==
To move $00010000 ... $007F0000 values to a data register:
<pre>
moveq.l #X,Dn ; X = $01 ... $7F
swap Dn
</pre>

To move $FF80FFFF ... $FFFEFFFF values to a data register:
<pre>
moveq.l #X,Dn ; X = $FFFFFF80 ... $FFFFFFFE
swap Dn
</pre>

==Shift/multiply data register==
<pre>
lsl.w #1,d0 -> add.w d0,d0 ; Saves 4 cycles
</pre>

<pre>
lsl.l #1,d0 -> add.l d0,d0 ; Saves 4 cycles
</pre>

<pre>
lsl.w #2,d0 -> add.w d0,d0 ; Saves 2 cycles
add.w d0,d0
</pre>

==Add to address register==
Useful when xxx is between -32768 and 32767.
<pre>
adda.w #xxx,a0 -> lea 10(a0),a0
</pre>

==Rotates==
<pre>
moveq.l #16,d0 -> swap d1
ror.l d0,d1
</pre>

<pre>
moveq.l #15,d0 -> swap d1
ror.l d0,d1 rol.l #1,d1
</pre>

[[Category:Code]]

NeoGeo Development Wiki - User contributions [en]

Optimization