What is the most sensible way to time C code running over FemtoRV on LiteOs?

[JamesTimothyMeech]

What is the best way to time C code running over LiteOs? I tried the standard time.c way of doing it but I got an error because of the cut down version of stdlib that the Makefile uses:

meechy@DESKTOP-5HD2OJR:~/Casino/learn-fpga/LiteX/software/Programs$ make timer.elf
 CC       lite_oled.o
../Libs/lite_oled.c: In function 'oled_init':
../Libs/lite_oled.c:10:8: warning: unused variable 'trigger_warning' [-Wunused-variable]   10 |    int trigger_warning; // LiteX synthesized without OLED support (graphics commands will be ignored)
      |        ^~~~~~~~~~~~~~~
 CC       lite_fb.o
../Libs/lite_fb.c: In function 'fb_line':
../Libs/lite_fb.c:212:111: warning: 'y' may be used uninitialized [-Wmaybe-uninitialize
]
  212 | ) | (((X) > fb_clip_x2)<<1) | (((Y) < fb_clip_y1)<<2) | (((Y) > fb_clip_y2)<<3)
      |                                                                            ^~

../Libs/lite_fb.c:221:11: note: 'y' was declared here
  221 |     int x,y,dx,dy,sx,sy;
      |           ^
../Libs/lite_fb.c:212:24: warning: 'x' may be used uninitialized [-Wmaybe-uninitialized]  212 | #define code(X,Y) ((X) < fb_clip_x1) | (((X) > fb_clip_x2)<<1) | (((Y) < fb_clip_y1)<<2) | (((Y) > fb_clip_y2)<<3)
      |                        ^
../Libs/lite_fb.c:221:9: note: 'x' was declared here
  221 |     int x,y,dx,dy,sx,sy;
      |         ^
 CC       lite_elf.o
 CC       lite_stdio.o
 CX       imgui.o
 CX       imgui_demo.o
 CX       imgui_draw.o
 CX       imgui_tables.o
 CX       imgui_widgets.o
 CX       imgui_sw.o
ar cq libliteos.a lite_oled.o lite_fb.o lite_elf.o lite_stdio.o imgui.o imgui_demo.o imgui_draw.o imgui_tables.o imgui_widgets.o imgui_sw.o
ranlib libliteos.a
 CC       timer.o
timer.c: In function 'main':
timer.c:9:14: warning: format '%ld' expects argument of type 'long int', but argument 2 has type 'time_t' {aka 'long long int'} [-Wformat=]
    9 |    printf("%ld\n", seconds/3600);
      |            ~~^     ~~~~~~~~~~~~
      |              |            |
      |              long int     time_t {aka long long int}
      |            %lld
 CC       crt0.o
 CC       sbrk.o
 CC       timer.elf
/opt/newlib/riscv/lib/gcc/riscv32-unknown-elf/12.2.0/../../../../riscv32-unknown-elf/bin/ld: warning: timer.elf has a LOAD segment with RWX permissions
/opt/newlib/riscv/lib/gcc/riscv32-unknown-elf/12.2.0/../../../../riscv32-unknown-elf/bin/ld: /home/meechy/Casino/learn-fpga/LiteX/build/gsd_orangecrab/software/libc/libc.a(libc_time_time.c.o): in function `time':
/home/meechy/Casino/learn-fpga/LiteX/build/gsd_orangecrab/software/libc/../../../../../../Enjoy_Digital/pythondata-software-picolibc/pythondata_software_picolibc/data/newlib/libc/time/time.c:55: undefined reference to `gettimeofday'
collect2: error: ld returned 1 exit status
make: *** [Makefile:12: timer.elf] Error 1
rm crt0.o timer.o sbrk.o

Would it be a good idea to try to use the full stdlib or is there some more simple timer functionality I can make use of to accurately time my programs?

[BrunoLevy]

Hi @JamesTimothyMeech,

LiteX has timer logic, controlled by LiteX CSRs (not to be confused with Risc-V CSRs).
Here is how I use it (for instance in learn-fpga/LiteX/software/DemoBundle/demos/tinyraytracer.c

#include <generated/soc.h>

uint32_t ticks;

void start_stopwatch() {
   timer0_en_write(0);
   timer0_reload_write(0);
   timer0_load_write(0xffffffff);
   timer0_en_write(1);
   timer0_update_value_write(1);
   ticks = timer0_value_read();
}

void stop_stopwatch(void) {
  timer0_update_value_write(1);
  ticks -= timer0_value_read();
}

Then use as follows:

   start_stopwatch();
  // ... do your computation
  stop_stopwatch();
  // now ticks contains the number of clock ticks between start_stopwatch() and stop_stopwatch()

Note that ticks is a 32 bits counter, so it may wrap-around, so I recommend to call it for portions of the computation, and accumulate kiloticks in another variable, for instance:

   uint32_t Kticks = 0;
   for(int iter=0; iter < Niter; ++iter) {
      start_stopwatch();
      // ... do your computation
      stop_stopwatch();
      Kticks += ticks / 1000;
   }

In the end you can display the elapsed time as follows:

void print_elapsed_time() {
  // Not using floats because printf() does not support them
  uint32_t milliseconds = (uint32_t)(frame_Kticks / (CONFIG_CLOCK_FREQUENCY / 1000000));
  uint32_t seconds = milliseconds / 1000;
  uint32_t minutes = seconds / 60;
  uint32_t rem_seconds = seconds % 60;
  uint32_t MHz = CONFIG_CLOCK_FREQUENCY / 1000000;
   
  printf(
      "Elapsed time=%02d:%02d (%d milliseconds)\n", 
      (int)minutes, (int)rem_seconds, (int)milliseconds
  );

  printf(
     "%s@%ldMHz\n",
     CONFIG_CPU_HUMAN_NAME,  MHz,
  );
}

How I figured out: I have seen that the memory test at the beginning of LiteX boot displays timings, so I took a look at libbase/memtest.c.

Hope this helps,
Best,
-- Bruno

[JamesTimothyMeech]

Thanks! So if the timer counts clock ticks and has a maximum value of 2^32 then it will wrap around every 2^32 / 48,000,000 ~ 90 seconds (my clock speed is 48 MHz). I'll try to figure out how to get hold of a longer timer without having to repeatedly call timer functions.

[BrunoLevy]

The only way I see is creating a 64 bits counter in LiteX (it is doable but will require diving a little bit inside the code of the SOC in Amaranth).
(Unless your CPU has an internal source of interupts with its own timer)

[JamesTimothyMeech]

Florent mentioned this on the LiteX Dischord chat:

You can add --timer-uptime to your target to have 64-bit time counters
this will add this: https://github.com/enjoy-digital/litex/blob/master/litex/soc/cores/timer.py#L90-L100

It seems that we can have 64 bit timers!
Link to Dischord chat: https://discord.com/channels/1031106128681127946/1031106128681127949