Direct Blitter wait vs Gfx Library

[sandruzzo]

is it true that on Stock A1200 waiting blitter with WaitBlit() is faster than direct wait since rom are 32bit?

[Galahad/FLT]

Originally Posted by sandruzzo

is it true that on Stock A1200 waiting blitter with WaitBlit() is faster than direct wait since rom are 32bit?

I think you have to consider all the extra instructions you need to execute to get to the system blit wait that would probably offset that.

[hooverphonique]

Depends on what you mean by "faster" - gfx lib WaitBlit is multitasking-compatible, doing it directly (i.e. a dff002 polling loop) just burns cpu cycles until the blitter is done.

[alkis]

I think OP refers to that

Always use the graphics.library WaitBlit() routine for your end of blitter code. It does not change any registers, it takes into account any revision of blitter chip and any unusual circumstances, and on an Amiga 1200 will execute faster (because in 32-bit ROM) than any code that you could write in chipram.

source: https://jvaltane.kapsi.fi/amiga/howtocode/blitter.html

[a/b]

Doesn't take icache and blitter nasty bit into account. In the best case for using a gfx call, it's situationally better, it really depends what you are doing.
Realistically, no, it isn't faster than embedded "optional" read + bit test + branch.
If you are super concerned about compatibility with every chipset in existance, then it makes sense to call WaitBlit(), otherwise it's slower.
You could simply follow the trail, look at the actual ROM code, and compare it to what you are doing and decide what's faster.

[paraj]

I checked KS 1.3,2.0,3.0 and 3.1, and there seems to be very little overhead in calling WaitBlit, and the only difference from what you'd normally write yourself is 3.0/3.1 doing a CIA access before polling DMACONR (if the blit wasn't finished when the routine started). 1.3/2.0 uses NOPs instead.

If you're doing a blit where the polling loop might steal cycles from the blitter then it seems to me that it would nearly always be best to use WaitBlit rather than rolling your own loop. The benefit is none/marginal on 020+ (for the reasons a/b mentions) if your code is equivalent, but it could be quite a bit faster on 68000.

[mark_k]

You could put the WaitBlit routine address in an address register, to allow you to do e.g. JSR (A5) to call it, to eliminate a long JMP. And if the call is at the end of a subroutine, do JMP (A5) instead.

[Bruce Abbott]

The most efficient WaitBlit() is the one you don't call. If you are worried about how long it will take you shouldn't be doing it.

[Galahad/FLT]

Originally Posted by mark_k

You could put the WaitBlit routine address in an address register, to allow you to do e.g. JSR (A5) to call it, to eliminate a long JMP. And if the call is at the end of a subroutine, do JMP (A5) instead.

There would be no long JMP, it would be a -xxx(a6) JSR

[mark_k]

I meant, having the address of WaitBlit() in a register allows you to avoid the indirect absolute long jump (which involves chip RAM access if GfxBase is in chip), e.g.

; GfxBase in A6
MOVEA.L (_LVOWaitBlit+2,A6),A5   ;Put address of (ROM) WaitBlit() routine in A5
... set up and start blit ...
JSR (A5)
... set up next blit ...
JSR (A5)
... set up last blit ...
JMP (A5)     ; Instead of JSR then RTS