macro ef_sys_write_it buf* {
    xor esp, esp                        ; Initialize string index counter

    @@:
        mov al, byte[buf + esp]         ; Move next character into 'al'

        cmp al, 0                       ; Compare character to '\0'
        je @f                           ; End loop when reaches '\0'

        mov eax, sys_write              ; Set 'write' syscall
        mov edi, sys_stdout             ; Set output file
        lea esi, [buf + esp]            ; Load character address to print
        mov edx, 1                      ; Set to print one character
        syscall

        inc esp                         ; Increment character index
        jmp @b                          ; Restarts loop
    @@:
}

macro ef_sys_write_ct buf* {
    xor edx, edx                        ; Initialize string index counter

    @@:
        mov al, byte[buf + edx]         ; Move next character into 'al'

        cmp al, 0                       ; Compare character to '\0'
        je @f                           ; End loop when reaches '\0'

        inc edx                         ; Increment character index
        jmp @b                          ; Restarts loop
    @@:
        mov esi, buf                    ; Load character address to print
        mov eax, sys_write              ; Set 'write' syscall
        mov edi, sys_stdout             ; Set output file
        syscall
}
    

#!/bin/bash

echo "[INFO] Syscall at each iteration implementation"
time for x in {0..20000}; do ./implementation_one; done

echo "[INFO] Single syscall implementation"
time for x in {0..20000}; do ./implementation_two; done
    

[INFO] Syscall at each iteration implementation

real 0m8.545s
user 0m5.741s
sys 0m3.537s

[INFO] Single syscall implementation

real 0m9.885s
user 0m6.430s
sys 0m4.257s
    

~$ fasm test_print.asm test_print1 -d TEST_NAME=print1 -d TEST_COUNT=20000000
flat assembler version 1.73.32 (16384 kilobytes memory)
2 passes, 223 bytes.

~$ fasm test_print.asm test_print2 -d TEST_NAME=print2 -d TEST_COUNT=20000000
flat assembler version 1.73.32 (16384 kilobytes memory)
2 passes, 223 bytes.

~$ time ./test_print1 > /dev/null

real 0m23.263s
user 0m7.888s
sys 0m15.335s
~$ time ./test_print2 > /dev/null

real 0m1.874s
user 0m0.675s
sys 0m1.194s

format ELF64 executable 3
segment executable
entry   $
match =TEST_COUNT, TEST_COUNT { define TEST_COUNT 10000 }
match =TEST_NAME, TEST_NAME { define TEST_NAME print0 }
        mov     rcx, TEST_COUNT
  @@:
        push    rcx
        lea     rax, [hello_world]
match name, TEST_NAME { call    name }
        pop     rcx
        loop    @b
        mov     rax, 60
        xor     dil, dil
        syscall

  print0:
        retn

  print1:
        push    1
        pop     rdi
        mov     rsi, rax
        mov     rax, rdi
  @@:
        cmp     byte [rsi], 0
        jz      @f
        mov     rax, rdi
        mov     rdx, rdi
        syscall
        inc     rsi
        jmp     @b
  @@:
        retn

  print2:
        push    1
        or      rdx, -1
        mov     rsi, rax
        pop     rdi
  @@:
        inc     rdx
        cmp     byte [rax + rdx], 0
        jnz     @b
        mov     rax, rdi
        syscall
        retn

  hello_world           db 'Hello world!', 10, 0
    

I don't know about you, but I have a significant difference.

OP used the shell to launch the task repeatedly, and the task was very short, so the overhead of launching and terminating will be the major bottleneck there. Add to that the normal randomness of other processes interrupting everything and you get useless variable results.

In his version, I am at least confused by the command xor esp, esp

ESP is used as a normal register. If you don't need the stack then it is perfectly fine to do that (as long as you use an OS in protected mode, or you disable interrupts in real mode).

There is another thread I posted about using ESP that way. And nothing goes wrong, it all works just fine.

The timings will be meaningless because of the overhead of many other things in the system that dwarf the thing you want to measure.

Better to start the process only once and run the loop in the process itself.

revolution wrote:

ESP is used as a normal register. If you don't need the stack then it is perfectly fine to do that (as long as you use an OS in protected mode, or you disable interrupts in real mode).

There is another thread I posted about using ESP that way. And nothing goes wrong, it all works just fine.

That's not the point. In compatibility with another program. Macros are good, but they must take into account the many possibilities of using code. Besides xor esp, esp, I am also confused by @@ labels instead of named local labels.