noob question

[Pixelfill]

So I'm just starting out, and fascinated by the 68000 optimisations thread

which got me wondering, I've seen numerous ways of clearing registers, and was wondering which of the following is the recommended way to clear a data register.

sub.l dn, dn 

moveq.l #0, dn 

eor dn, dn 

clr.l dn

similarly which is "best" for an address register.

movea.l #0, an 

suba.l an, an 

moveq.l #0, dn 
move.l dn, an 

eor dn, dn 
move.l dn, an 

clr.l dn 
move.l dn, an

I appreciate "best" is subjective, and affected by context, but I would appreciate some insight into the pros and cons of each approach, and what any side-effects may be (clobbered registers / flags etc.) I'm sure there are other alternative approaches too …

I'm very green when it comes to 68K assembler, so this is probably way too deep a topic for me, but as I said the optimisation thread piqued my interest.

thanks

Mike

[phx]

        moveq   #0,Dn
        suba.l  An,An

[sparhawk]

This should be

        moveq   #0,Dn
        move.l  D0,An

But this is the same as

        suba.l  An,An

[Cyprian]

@sparhawk
that's two separate instructions/aims:

1) clear data register
"moveq #0,Dn"

2)clear address register
"suba.l An,An"

[sparhawk]

Yes. That makes sense.

[roondar]

While the above is 100% correct (in that the examples for clearing registers are either the fastest/smallest or both), I'd argue that focusing on this kind of optimization might not be the best way to go about it.

In code that is either time or space critical, I would definitely recommend using the examples as given (moveq / suba.l). However, there are many places in which a simple clr.w/clr.l effectively is just as good. My suggestion then is to use "what you like"*, unless you are trying to get the fastest (or smallest) possible code. Which is something you probably should only really do if you need to

*) Within reason, of course. As an example: move.l #0,a0 will work but it needlessly wasteful in terms of space and performance. A suba.l a0,a0 or clr.l a0 (or a moveq #0,d0 vs a clr.l d0), however are both usually "good enough".

Note this isn't to say you should just waste cycles or space without limits or reason. It's more that you're probably better off choosing the correct algorithms and then optimizing as needed instead of trying to do everything optimally all the time - pick your battles and all that.

[Pixelfill]

Originally Posted by roondar

While the above is 100% correct (in that the examples for clearing registers are either the fastest/smallest or both), I'd argue that focusing on this kind of optimization might not be the best way to go about it.

In code that is either time or space critical, I would definitely recommend using the examples as given (moveq / suba.l). However, there are many places in which a simple clr.w/clr.l effectively is just as good. My suggestion then is to use "what you like"*, unless you are trying to get the fastest (or smallest) possible code. Which is something you probably should only really do if you need to

*) Within reason, of course. As an example: move.l #0,a0 will work but it needlessly wasteful in terms of space and performance. A suba.l a0,a0 or clr.l a0 (or a moveq #0,d0 vs a clr.l d0), however are both usually "good enough".

Note this isn't to say you should just waste cycles or space without limits or reason. It's more that you're probably better off choosing the correct algorithms and then optimizing as needed instead of trying to do everything optimally all the time - pick your battles and all that.

thanks to all for chipping in, I’m fully on board with the suggestion to use what’s appropriate, I’m of the school that code should be easy to read and understand, rather than “clever” in my day to day life.

If I’m understanding you the main differences are down to assembled executable size, and cycle execution time. Is the best place to find cycle times the Motorola documentation, or is there a more accessible document?

The other consideration when starting out teaching myself is that I’m inspecting available sourcecode to learn. Most of this is demo/intro code which by definition is either trying to be size conscious or speed conscious, so being able to understand what some of these alternative optimisations do will help aid understanding.

Thanks again

[roondar]

The Motorola documentation (which, helpfully, is still on NXP's site) is awesome. Contains all you need to know. However, if all you want is a table of instructions and cycle uses I'd suggest looking at http://oldwww.nvg.ntnu.no/amiga/MC68...000timing.HTML

Which is perhaps easier to click through than reading the manual.