Re: Testing alternatives to functions from lib1funcs.S

Am 21.04.24 um 10:08 schrieb Wolfgang Hospital:>   Dear all,> 
> Is there a test scaffold for the functions from lib1funcs.S,
> correctness, size&speed over the variety of 8-bit AVR cores?

Size is the easiest one: Just determine the size of, say
-nodefaultlibs -nostartfiles against a respective compilation
with -Wl,-u,__divmodqi4

Benchmarking speed is not so easy.  I am using the avrtest core
simulator because it is fast, simulating a core is enough, and
it has some extra features, e.g. get random values and get values
out of the target, e.g. LOG_FMT_DOUBLE ("double = %f\n", x);

https://github.com/sprintersb/atest

See the end of this mail for an example.

For correctness, most of the functions are tested off testsuite
by hand-written programs that test new implementations against
existing ones, like in the code below.  Such tests don't make sense
any more when the new version is integrated.  And performance
tests / comparisons are misplaced in the GCC testsuite anyway.

> Is there a more comprehensive statement of calling conventions than 
> https://gcc.gnu.org/wiki/avr-gcc#Exceptions_to_the_Calling_Convention, 

It is comprehensive, but likely not complete.  For completeness, you'll
have to resort to avr.md and the files it includes.  There is no
table that lists the non-ABT stuff though; you'll have to find the
transparent calls, usually of type "xcall".  Notice however that
such functions may be ABI or non-ABI.  Transparent calls are basically
used for two purposes:
* Non-ABI calls like some mul stuff that gets param in X reg.
* ABI calls that don't clobber all callee-used regs, in order to
   model the smaller footprint.

> in particular explicitly stating which functions are guaranteed to have 
> __zero_reg__ 0 on entry/where it suffices to have __zero_reg__ 0 on 
> return as opposed to preserving its value?

When a function does /not/ have zero_reg=0 on entry, then the compiler
or libc (or application code) has a bug.  Same when zero_reg!=0 on
exit.

> I've been tinkeringaround, the "ldi  r_cnt, 9""rjmp entry point" in 
> __udivmodqi4 instead of "ldi  r_cnt, 8""lsl  r_arg1" annoying me for 
> years. (Biggest relative strict improvement I found, FWIW.)

I went ahead and applied it, see https://gcc.gnu.org/PR114794

In order to test it, I ran the following code with
avrtest_log -q -no-log ...

<CODE>
#include <stdint.h>
#include "avrtest.h"

volatile uint8_t q8, my_q8;
volatile uint8_t r8, my_r8;

extern void __udivmodqi4 (void);
extern void my_udivmodqi4 (void);

__asm("\n"
"r_rem	= 25	/* remainder */" "\n"
"r_arg1	= 24	/* dividend, quotient */" "\n"
"r_arg2	= 22	/* divisor */" "\n"
"r_cnt	= 23	/* loop count */" "\n"
".pushsection .text" "\n"
".global my_udivmodqi4" "\n"
"my_udivmodqi4:" "\n\t"
"	sub	r_rem,r_rem	; clear remainder and carry" "\n\t"
"	ldi	r_cnt,8		; init loop counter" "\n\t"
"	lsl	r_arg1		; shift dividend" "\n\t"
"__udivmodqi4_loop:" "\n\t"
"	rol	r_rem		; shift dividend into remainder" "\n\t"
"	cp	r_rem,r_arg2	; compare remainder & divisor" "\n\t"
"	brcs	__udivmodqi4_ep	; remainder <= divisor" "\n\t"
"	sub	r_rem,r_arg2	; restore remainder" "\n\t"
"__udivmodqi4_ep:" "\n\t"
"	rol	r_arg1		; shift dividend (with CARRY)" "\n\t"
"	dec	r_cnt		; decrement loop counter" "\n\t"
"	brne	__udivmodqi4_loop" "\n\t"
"	com	r_arg1		; complement result" "\n\t"
"				; because C flag was complemented in loop" "\n\t"
"	ret" "\n\t"
".popsection");

static inline __attribute__((__always_inline__))
void my_divmod8 (volatile uint8_t *pq, volatile uint8_t *prem,
                  uint8_t dividend, uint8_t divisor)
{
     register uint8_t rem asm("25");
     register uint8_t q asm("24");
     register uint8_t r22 asm("22") = divisor;
     register uint8_t r24 asm("24") = dividend;
     asm ("%~call %x[func]"
          : "=r" (q), "=r" (rem)
          : "r" (r22), "r" (r24), [func] "i" (my_udivmodqi4)
          : "r23");
     *pq = q;
     *prem = rem;
}

static inline __attribute__((__always_inline__))
void divmod8 (volatile uint8_t *pq, volatile uint8_t *prem,
               uint8_t dividend, uint8_t divisor)
{
     register uint8_t rem asm("25");
     register uint8_t q asm("24");
     register uint8_t r22 asm("22") = divisor;
     register uint8_t r24 asm("24") = dividend;
     asm ("%~call %x[func]"
          : "=r" (q), "=r" (rem)
          : "r" (r22), "r" (r24), [func] "i" (__udivmodqi4)
          : "r23");
     *pq = q;
     *prem = rem;
}

void bench_divmod8 (void)
{
     uint8_t a = 0;
     do
     {
         uint8_t b = 1;
         do
         {
             PERF_START_CALL (1);
             divmod8 (&q8, &r8, a, b);
             PERF_STOP (1);

             PERF_START_CALL (2);
             my_divmod8 (&my_q8, &my_r8, a, b);
             PERF_STOP (2);

             if (q8 != my_q8 || r8 != my_r8)
                 __builtin_abort();
         } while (++b);
     } while (++a);
}

int main (void)
{
     bench_divmod8();
     PERF_DUMP_ALL;
     return 0;
}
</CODE>

The input space is only 16 bits wide, so a full coverage is possible.
With larger input spaces, one could use avrtest_[p]rand() or
similar means to randomize the input.

The output is as follows:

$ avrtest_log -mmcu=avr5 -no-log ben.elf -m 100000000 -q

--- Dump # 1:
  Timer T1 "" (65280 rounds):  00ec--00fc
               Instructions        Ticks
     Total:      3765820         5222400
     Mean:            57              80
     Stand.Dev:      0.9             0.0
     Min:             57              80
     Max:             65              80
     Calls (abs) in [   2,   3] was:   2 now:   2
     Calls (rel) in [   0,   1] was:   0 now:   0
     Stack (abs) in [08fb,08f9] was:08fb now:08fb
     Stack (rel) in [   0,   2] was:   0 now:   0

            Min round Max round    Min tag           /   Max tag
     Calls       -all-same-                          /
     Stack       -all-same-                          /
     Instr.         1     65026    -no-tag-          /   -no-tag-
     Ticks       -all-same-                          /

  Timer T2 "" (65280 rounds):  0108--0116
               Instructions        Ticks
     Total:      3569980         4896000
     Mean:            54              75
     Stand.Dev:      0.9             0.0
     Min:             54              75
     Max:             62              75
     Calls (abs) in [   2,   3] was:   2 now:   2
     Calls (rel) in [   0,   1] was:   0 now:   0
     Stack (abs) in [08fb,08f9] was:08fb now:08fb
     Stack (rel) in [   0,   2] was:   0 now:   0

            Min round Max round    Min tag           /   Max tag
     Calls       -all-same-                          /
     Stack       -all-same-                          /
     Instr.         1     65026    -no-tag-          /   -no-tag-
     Ticks       -all-same-                          /

So the new code requires 5 ticks less (changed from 80 to 75)

"Calls" is the (relative or absolute) call depth.
"Stack" is the (relative or absolute) stack usage.

Johann

> Recommendations for a platform to vent such ideas welcome (I know of 
> stackoverflow.com).
> 
> regards
> 
> W. Hospital
> 
> -- 
> Wolfgang Hospital