/* -------------------------------------------------------
   benchmark.c

   Einfacher Geschwindigkeitstest fuer Mikrocontroller

   MCU   :  ATmega328p
   Takt  :

   19.11.2025  R. Seelig
   ------------------------------------------------------ */

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <stdio.h>

// AVRtest: https://github.com/sprintersb/atest
#include "avrtest.h"

#define NI __attribute__((noinline,noclone))

#define loops_int8   100000
#define loops_int16  50000
#define loops_int32  20000
#define loops_float  8000

#define n_int8   16
#define n_int16  16
#define n_int32  16
#define n_float  16

// Benchmark-Funktionen
NI
void benchmark_int8 (uint8_t *array)
{
  uint8_t a, b, c, mix;

  for (uint32_t loop = 0; loop < loops_int8; loop++)
    {
      for (uint32_t i = 0; i < n_int8; i++)
        {
          a = array[i];
          b = (a * 17) + (i ^ 0x55);
          c = (b * 23) ^ a;
          mix = a ^ (b << 1) ^ (c >> 2);
          mix = (mix << 3) | (mix >> 5);
          array[i] = mix;
        }
    }
}

NI
void benchmark_int16 (uint16_t *array)
{
  uint16_t a, b, c, mix;

  for (uint32_t loop = 0; loop < loops_int16; loop++)
    {
      for (uint32_t i = 0; i < n_int16; i++)
        {
          a = array[i];
          b = (a * 123) + (i ^ 0xAAAA);
          c = (b * 97) ^ a;
          mix = a ^ (b << 1) ^ (c >> 2);
          mix = (mix << 3) | (mix >> 5);
          array[i] = mix;
        }
    }
}

NI
void benchmark_int32 (uint32_t *array)
{
  uint32_t a, b, c, mix;

  for (uint32_t loop = 0; loop < loops_int32; loop++)
    {
      for (uint32_t i = 0; i < n_int32; i++)
        {
          a = array[i];
          b = (a * 12345UL) + (i ^ 0xAAAA5555UL);
          c = (b * 98765UL) ^ a;
          mix = a ^ (b << 1) ^ (c >> 2);
          mix = (mix << 3) | (mix >> 5);
          array[i] = mix;
        }
    }
}

void benchmark_float (float *array)
{
  float a, b, c, mix;

  for (uint32_t loop = 0; loop < loops_float; loop++)
    {
      for (uint32_t i = 0; i < n_float; i++)
        {
          a = array[i];
          b = a * 1.2345f + (float)i;
          c = b * 0.9876f - a;
          mix = a + b - c;
          array[i] = mix;
        }
    }
}

uint32_t cyc_8, cyc_16, cyc_32, cyc_float;

void run_benchmark (void)
{
  uint8_t  array8[n_int8];
  uint16_t array16[n_int16];
  uint32_t array32[n_int32];
  float    arrayf[n_float];

  // Arrays initialisieren
  for (size_t i = 0; i < n_int8; i++)
    array8[i] = i * 3 + 1;

  for (size_t i = 0; i < n_int16; i++)
    array16[i] = i * 7 + 11;

  for (size_t i = 0; i < n_int32; i++)
    array32[i] = i * 123 + 456;

  for (size_t i = 0; i < n_float; i++)
    arrayf[i] = (float)i * 0.5f + 1.0f;

  // Benchmarks durchfuehren
  printf ("int_8 Benchmark... ");
  avrtest_cycles_call ();
  benchmark_int8 (array8);
  cyc_8 = avrtest_cycles ();
  printf ("done\n");

  printf ("int_16 Benchmark... ");
  avrtest_cycles_call ();
  benchmark_int16 (array16);
  cyc_16 = avrtest_cycles ();
  printf ("done\n");

  printf ("int_32 Benchmark... ");
  avrtest_cycles_call ();
  benchmark_int32 (array32);
  cyc_32 = avrtest_cycles ();
  printf ("done\n");

  printf("float Benchmark... ");
  avrtest_cycles_call ();
  benchmark_float (arrayf);
  cyc_float = avrtest_cycles ();
  printf ("done\n");
}

void print_cycles (const char *labl, uint32_t cyc)
{
  uint32_t mils = cyc / (F_CPU / 1000);
  uint16_t sec = mils / 1000;
  uint16_t ms = mils % 1000;
  
  printf ("cycles %s: % 9" PRIu32 " = %u.%03u s\n", labl, cyc, sec, ms);
}

/* --------------------------------------------------------
   main
   -------------------------------------------------------- */
int main (void)
{
  run_benchmark();

  printf ("F_CPU = %lu\n", F_CPU);
  print_cycles ("int8 ", cyc_8);
  print_cycles ("int16", cyc_16);
  print_cycles ("int32", cyc_32);
  print_cycles ("float", cyc_float);

  return 0;
}