Re: Stack vs stackless operation

Paul Rubin <no.email@nospam.invalid> writes:

anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:

!@ is now the nonatomic version.

>
Is the nonatomic one useful often?

Some numbers of uses in the Gforth image:

11 !@
3  atomic!@
66 +!

We've done without it all this time.

Sure, you can replace it with DUP @ >R ! R>.  Having a word for that
relieves the programmer of producing such a sequence (possibly with a
bug) and the reader of having to analyse what's going on here.

I have now added stack-state variants for !@, resulting in better
performance in some cases.  Is !@ used often enough to merit the extra
build time of Gforth?  That's not clear, but the benefit I see is that
I want to provide a system where the programmer does not have to
wonder whether he should avoid !@ for better performance.

I also tried out another variant that uses !@:

: exchange4 ( addr1 addr2 -- )
    dup @ rot !@ swap ! ;

The resulting code for EXCHANGE, EXCHANGE4, and EXCHANGE2 (the latter
without !@):

see-code exchange        see-code exchange4     see-code exchange2
over    1->2             dup    1->2            dup >r     1->1
  mov     r15,$08[r12]     mov     r15,r8       >r    1->1
@    2->2                @    2->2                mov     -$08[r13],r8
  mov     r15,[r15]        mov     r15,[r15]      sub     r13,$08
swap    2->3             rot    2->3            @    1->1
  add     r12,$08          mov     r9,$08[r12]    mov     r8,[r8]
  mov     r9,r8            add     r12,$08      over    1->2
  mov     r8,[r12]       !@    3->2               mov     r15,$08[r12]
!@    3->2                 mov     rax,r15      @    2->2
  mov     rax,r15          mov     r15,[r9]       mov     r15,[r15]
  mov     r15,[r9]         mov     [r9],rax     r>    2->3
  mov     [r9],rax       swap    2->3             mov     r9,$00[r13]
swap    2->3               add     r12,$08        add     r13,$08
  add     r12,$08          mov     r9,r8        !    3->1
  mov     r9,r8            mov     r8,[r12]       mov     [r9],r15
  mov     r8,[r12]       !    3->1              swap    1->2
!    3->1                  mov     [r9],r15       mov     r15,$08[r12]
  mov     [r9],r15       ;s    1->1               add     r12,$08
;s    1->1                 mov     rbx,$00[r13] !    2->0
  mov     rbx,$00[r13]     add     r13,$08        mov     [r15],r8
  add     r13,$08          mov     rax,[rbx]    ;s    0->1
  mov     rax,[rbx]        jmp     eax            mov     r8,$08[r12]
  jmp     eax                                     add     r12,$08
                                                  mov     rbx,$00[r13]
                                                  add     r13,$08
                                                  mov     rax,[rbx]
                                                  jmp     eax

EXCHANGE performs 1 instruction less than EXCHANGE2, EXCHANGE4
performs 2 instructions less than EXCHANGE2; both contain three less
primitives.

Performance on Zen4:
   exchange      exchange4       exchange2
  748_033_428    699_870_875    809_204_577  cycles
3_610_871_416  3_510_578_833  3_710_662_751  instructions

- anton
--
M. Anton Ertl  http://www.complang.tuwien.ac.at/anton/home.html
comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
     New standard: https://forth-standard.org/
EuroForth 2023 proceedings: http://www.euroforth.org/ef23/papers/
EuroForth 2024 proceedings: http://www.euroforth.org/ef24/papers/