/* -------------------------------------------------------
                        benchmark2_portable.c

   MCU   :  CH32V003
   Takt  : 48 MHz

   21.11.2025  R. Seelig
 ------------------------------------------------------- */

#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#include "ch32fun.h"
#include "ch32v003_gpio.h"
#include "systick.h"
#include "my_printf.h"
#include "uart.h"

#define printf my_printf
#define baud 115200

volatile uint32_t bench_checksum = 0;

uint32_t prog_millis8;
uint32_t prog_millis16;
uint32_t prog_millis32;
uint32_t prog_millisfl;

void my_putchar(char ch)
{
    uart_putchar(ch);
}

#define loops_int8   500000
#define loops_int16  500000
#define loops_int32  50000
#define loops_float  20000

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

/* -------------------------------------------------------
                Benchmark-Funktionen
   ------------------------------------------------------ */

void benchmark_int8(volatile uint8_t *array)
{
    uint32_t loop, i;
    uint8_t a, b, c, mix;

    for(loop = 0; loop < loops_int8; loop++)
    {
        for(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;
        }
    }

    uint32_t cs = 0;
    for(i = 0; i < n_int8; i++) cs += array[i];
    bench_checksum += cs;
}


void benchmark_int16(volatile uint16_t *array)
{
    uint32_t loop, i;
    uint16_t a, b, c, mix;

    for(loop = 0; loop < loops_int16; loop++)
    {
        for(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;
        }
    }

    uint32_t cs = 0;
    for(i = 0; i < n_int16; i++) cs += array[i];
    bench_checksum += cs;
}


void benchmark_int32(volatile uint32_t *array)
{
    uint32_t loop, i;
    uint32_t a, b, c, mix;

    for(loop = 0; loop < loops_int32; loop++)
    {
        for(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;
        }
    }

    uint32_t cs = 0;
    for(i = 0; i < n_int32; i++) cs += array[i];
    bench_checksum += cs;
}


void benchmark_float(volatile float *array)
{
    uint32_t loop, i;
    float a, b, c, mix;

    for(loop = 0; loop < loops_float; loop++)
    {
        for(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 cs = 0;
    for(i = 0; i < n_float; i++)
        cs += (uint32_t)(array[i] * 1000.0f);

    bench_checksum += cs;
}


/* -------------------------------------------------------
                Benchmark ausführen
   ------------------------------------------------------ */
void run_benchmark()
{
    volatile uint8_t  array8[n_int8];
    volatile uint16_t array16[n_int16];
    volatile uint32_t array32[n_int32];
    volatile float    arrayf[n_float];

    uint32_t i;

    for(i = 0; i < n_int8; i++)  array8[i] = i * 3 + 1;
    for(i = 0; i < n_int16; i++) array16[i] = i * 7 + 11;
    for(i = 0; i < n_int32; i++) array32[i] = i * 123 + 456;
    for(i = 0; i < n_float; i++) arrayf[i] = (float)i * 0.5f + 1.0f;

    printf("\n\rint_8 Benchmark\n\r");
    prog_millis8 = systick_millis;
    benchmark_int8(array8);
    prog_millis8 = systick_millis - prog_millis8;
    printf("Zeit: %d.%d sek\n\r", prog_millis8 / 1000, (prog_millis8 % 1000) / 10);
    printf("-----------------------------\n\r");

    printf("\n\rint_16 Benchmark\n\r");
    prog_millis16 = systick_millis;
    benchmark_int16(array16);
    prog_millis16 = systick_millis - prog_millis16;
    printf("Zeit: %d.%d sek\n\r", prog_millis16 / 1000, (prog_millis16 % 1000) / 10);
    printf("-----------------------------\n\r");

    printf("\n\rint32 Benchmark\n\r");
    prog_millis32 = systick_millis;
    benchmark_int32(array32);
    prog_millis32 = systick_millis - prog_millis32;
    printf("Zeit: %d.%d sek\n\r", prog_millis32 / 1000, (prog_millis32 % 1000) / 10);
    printf("-----------------------------\n\r");

    printf("\n\rfloat Benchmark\n\r");
    prog_millisfl = systick_millis;
    benchmark_float(arrayf);
    prog_millisfl = systick_millis - prog_millisfl;
    printf("Zeit: %d.%d sek\n\r", prog_millisfl / 1000, (prog_millisfl % 1000) / 10);
    printf("-----------------------------\n\r");

    printf("Checksumme: %x\n\r", bench_checksum);
}


int main(void)
{
    uint32_t gesamtzeit;

    SystemInit();
    delay(100);
    systick_init();
    uart_init(baud);

  printf("\n\r --------------------------------------\n\r");
  printf(    " CH32V003: (Pseudo)benchmark           \n\r");
  printf(    "                                       \n\r");
  printf(    " 21.11.2025  R. Seelig                 \n\r");
  printf(    " --------------------------------------\n\n\r");

    run_benchmark();

    gesamtzeit = prog_millis8 + prog_millis16 + prog_millis32 + prog_millisfl;
    printf("\n\rZeit gesamt: %d.%d sek\n\r", gesamtzeit / 1000, (gesamtzeit % 1000) / 10);

    printf("Gesamt-Checksumme: %x\n\r", bench_checksum);

    while(1);
}