/* ALINX PI-AR035-F1-1 / CVE2 EP05 performance benchmark firmware. */
#include <stdint.h>
#include <stdarg.h>

#define UART_TX        (*(volatile unsigned char *)0x10000000u)
#define UART_STATUS    (*(volatile unsigned int  *)0x10000004u)

#define CLK_HZ         50000000u
#define COREMARK_ITERS 50u

#ifdef __OPTIMIZE_SIZE__
#define VARIANT_NAME "Os"
#else
#define VARIANT_NAME "O2"
#endif

uint32_t g_trap_count;
uint32_t g_trap_cause;
uint32_t g_trap_epc;
uint32_t g_irq_count;
uint32_t g_last_irq;

extern int coremark_main(void);

static void putc(char c)
{
    while (UART_STATUS & 1u)
        ;
    UART_TX = (unsigned char)c;
}

void uart_send_char(char c)
{
    putc(c);
}

static void print_uint(uint32_t v, uint32_t base, uint32_t width, uint32_t zero)
{
    char buf[12];
    uint32_t n = 0, i;
    if (v == 0u) {
        buf[n++] = '0';
    } else {
        while (v && n < 12u) {
            uint32_t d = v % base;
            buf[n++] = (char)(d < 10u ? ('0' + d) : ('a' + d - 10u));
            v /= base;
        }
    }
    while (n < width) buf[n++] = zero ? '0' : ' ';
    for (i = n; i > 0u; --i)
        putc(buf[i - 1u]);
}

static void print_uint64(uint64_t v, uint32_t base, uint32_t width, uint32_t zero)
{
    char buf[24];
    uint32_t n = 0, i;
    if (v == 0ull) {
        buf[n++] = '0';
    } else {
        while (v && n < 24u) {
            uint32_t d = (uint32_t)(v % base);
            buf[n++] = (char)(d < 10u ? ('0' + d) : ('a' + d - 10u));
            v /= base;
        }
    }
    while (n < width) buf[n++] = zero ? '0' : ' ';
    for (i = n; i > 0u; --i)
        putc(buf[i - 1u]);
}

static void print_int(int32_t v, uint32_t width, uint32_t zero)
{
    if (v < 0) {
        putc('-');
        print_uint((uint32_t)(-v), 10u, width ? width - 1u : 0u, zero);
    } else {
        print_uint((uint32_t)v, 10u, width, zero);
    }
}

int ee_printf(const char *fmt, ...)
{
    va_list ap;
    int n = 0;
    va_start(ap, fmt);
    while (*fmt) {
        if (*fmt != '%') {
            putc(*fmt++);
            ++n;
            continue;
        }
        ++fmt;
        uint32_t zero = 0u, width = 0u, longlong = 0u;
        if (*fmt == '0') { zero = 1u; ++fmt; }
        while (*fmt >= '0' && *fmt <= '9') {
            width = width * 10u + (uint32_t)(*fmt - '0');
            ++fmt;
        }
        if (*fmt == 'l') {
            ++fmt;
            if (*fmt == 'l') { longlong = 1u; ++fmt; }
        }
        switch (*fmt) {
        case 'u':
            if (longlong)
                print_uint64(va_arg(ap, unsigned long long), 10u, width, zero);
            else
                print_uint((uint32_t)va_arg(ap, unsigned int), 10u, width, zero);
            break;
        case 'd':
            print_int((int32_t)va_arg(ap, int), width, zero);
            break;
        case 'x':
            print_uint((uint32_t)va_arg(ap, unsigned int), 16u, width, zero);
            break;
        case 'c':
            putc((char)va_arg(ap, int));
            break;
        case 's': {
            const char *s = va_arg(ap, const char *);
            while (*s) { putc(*s++); ++n; }
            break;
        }
        case '%':
            putc('%');
            break;
        default:
            putc('%');
            if (*fmt) putc(*fmt);
            break;
        }
        if (*fmt) ++fmt;
        ++n;
    }
    va_end(ap);
    return n;
}

static inline uint32_t rdcycleh(void)
{
    uint32_t v;
    __asm__ volatile ("csrr %0, 0xb80" : "=r"(v));
    return v;
}

static inline uint32_t rdinstreth(void)
{
    uint32_t v;
    __asm__ volatile ("csrr %0, 0xb82" : "=r"(v));
    return v;
}

/* CVE2 keeps a full 64-bit mcycle.  Read low/high/low so a low-word wrap
   between the two reads cannot produce a torn 64-bit value. */
static inline uint64_t rdcycle64(void)
{
    uint32_t hi, lo, hi2;
    do {
        hi  = rdcycleh();
        __asm__ volatile ("csrr %0, 0xb00" : "=r"(lo));
        hi2 = rdcycleh();
    } while (hi != hi2);
    return ((uint64_t)hi << 32) | (uint64_t)lo;
}

static inline uint64_t rdinstret64(void)
{
    uint32_t hi, lo, hi2;
    do {
        hi  = rdinstreth();
        __asm__ volatile ("csrr %0, 0xb02" : "=r"(lo));
        hi2 = rdinstreth();
    } while (hi != hi2);
    return ((uint64_t)hi << 32) | (uint64_t)lo;
}

static inline uint32_t rdcycle32(void)
{
    return (uint32_t)rdcycle64();
}

static inline uint32_t rdinstret32(void)
{
    return (uint32_t)rdinstret64();
}

static void delay(unsigned int n)
{
    volatile unsigned int i;
    for (i = 0u; i < n; ++i)
        __asm__ volatile ("nop");
}

/* libc-free helpers (compiler may emit calls for block moves). */
void *memcpy(void *dst, const void *src, uint32_t n)
{
    uint8_t *d = (uint8_t *)dst;
    const uint8_t *s = (const uint8_t *)src;
    while (n--) *d++ = *s++;
    return dst;
}

void *memset(void *dst, int c, uint32_t n)
{
    uint8_t *d = (uint8_t *)dst;
    while (n--) *d++ = (uint8_t)c;
    return dst;
}

void *memmove(void *dst, const void *src, uint32_t n)
{
    uint8_t *d = (uint8_t *)dst;
    const uint8_t *s = (const uint8_t *)src;
    if (d < s) { while (n--) *d++ = *s++; }
    else { d += n; s += n; while (n--) *--d = *--s; }
    return dst;
}

int memcmp(const void *a, const void *b, uint32_t n)
{
    const uint8_t *x = (const uint8_t *)a, *y = (const uint8_t *)b;
    while (n--) { if (*x != *y) return (int)*x - (int)*y; ++x; ++y; }
    return 0;
}

uint32_t strlen(const char *s)
{
    uint32_t n = 0;
    while (s[n]) ++n;
    return n;
}

/* Microbenchmark exports: same source compiled at -O2 and -Os. */
extern uint32_t bench_o2_crc32(const uint8_t *, uint32_t);
extern uint32_t bench_o2_memcpy_sum(const uint8_t *, uint8_t *, uint32_t, uint32_t);
extern uint32_t bench_o2_matmul(const int32_t *, const int32_t *, int32_t *, uint32_t);
extern uint32_t bench_o2_sieve(uint8_t *, uint32_t);

extern uint32_t bench_os_crc32(const uint8_t *, uint32_t);
extern uint32_t bench_os_memcpy_sum(const uint8_t *, uint8_t *, uint32_t, uint32_t);
extern uint32_t bench_os_matmul(const int32_t *, const int32_t *, int32_t *, uint32_t);
extern uint32_t bench_os_sieve(uint8_t *, uint32_t);

#define BENCH_N      4096u
#define MAT_N        16u

static uint8_t  g_src[BENCH_N] __attribute__((aligned(16)));
static uint8_t  g_dst[BENCH_N] __attribute__((aligned(16)));
static uint8_t  g_flags[BENCH_N] __attribute__((aligned(16)));
static int32_t  g_a[MAT_N * MAT_N];
static int32_t  g_b[MAT_N * MAT_N];
static int32_t  g_c[MAT_N * MAT_N];

typedef uint32_t (*crc_fn_t)(const uint8_t *, uint32_t);
typedef uint32_t (*copy_fn_t)(const uint8_t *, uint8_t *, uint32_t, uint32_t);
typedef uint32_t (*mat_fn_t)(const int32_t *, const int32_t *, int32_t *, uint32_t);
typedef uint32_t (*sieve_fn_t)(uint8_t *, uint32_t);

static void run_one(const char *tag, crc_fn_t crc, copy_fn_t copy,
                    mat_fn_t mat, sieve_fn_t sieve)
{
    uint32_t c0, c1, i0, i1;
    uint32_t sink;

    c0 = rdcycle32(); i0 = rdinstret32();
    sink = crc(g_src, BENCH_N);
    c1 = rdcycle32(); i1 = rdinstret32();
    ee_printf("BENCH %s CRC32 cycles=%u inst=%u sink=%08x\n", tag, c1 - c0, i1 - i0, sink);

    c0 = rdcycle32(); i0 = rdinstret32();
    sink = copy(g_src, g_dst, BENCH_N, 16u);
    c1 = rdcycle32(); i1 = rdinstret32();
    ee_printf("BENCH %s MEMCPY cycles=%u inst=%u sink=%08x\n", tag, c1 - c0, i1 - i0, sink);

    c0 = rdcycle32(); i0 = rdinstret32();
    sink = mat(g_a, g_b, g_c, MAT_N);
    c1 = rdcycle32(); i1 = rdinstret32();
    ee_printf("BENCH %s MATMUL16 cycles=%u inst=%u sink=%08x\n", tag, c1 - c0, i1 - i0, sink);

    c0 = rdcycle32(); i0 = rdinstret32();
    sink = sieve(g_flags, BENCH_N);
    c1 = rdcycle32(); i1 = rdinstret32();
    ee_printf("BENCH %s SIEVE cycles=%u inst=%u sink=%08x\n", tag, c1 - c0, i1 - i0, sink);
}

int main(void)
{
    uint32_t i;
    uint64_t c0, c1, i0, i1;
    unsigned long long cpi_milli, score_milli;

    delay(300000u);

    ee_printf("\nALINX AR035 CVE2 Performance EP05\n");
    ee_printf("VARIANT=%s CLK=%u BUILD=%s %s\n", VARIANT_NAME, CLK_HZ, __DATE__, __TIME__);

    {
        uint32_t lo0, hi0, lo1, hi1;
        __asm__ volatile ("csrr %0, 0xb00" : "=r"(lo0));
        __asm__ volatile ("csrr %0, 0xb80" : "=r"(hi0));
        delay(100000u);
        __asm__ volatile ("csrr %0, 0xb00" : "=r"(lo1));
        __asm__ volatile ("csrr %0, 0xb80" : "=r"(hi1));
        ee_printf("COUNTER_A lo=%08x hi=%08x\n", lo0, hi0);
        ee_printf("COUNTER_B lo=%08x hi=%08x\n", lo1, hi1);
    }

    for (i = 0; i < BENCH_N; ++i) {
        g_src[i] = (uint8_t)(i * 7u + 3u);
        g_flags[i] = 0;
    }
    for (i = 0; i < MAT_N * MAT_N; ++i) {
        g_a[i] = (int32_t)(i + 1u);
        g_b[i] = (int32_t)(i * 2u + 1u);
        g_c[i] = 0;
    }

    run_one("O2", bench_o2_crc32, bench_o2_memcpy_sum, bench_o2_matmul, bench_o2_sieve);
    run_one("OS", bench_os_crc32, bench_os_memcpy_sum, bench_os_matmul, bench_os_sieve);

    ee_printf("COREMARK_BEGIN variant=%s iterations=%u\n", VARIANT_NAME, COREMARK_ITERS);
    c0 = rdcycle64(); i0 = rdinstret64();
    (void)coremark_main();
    c1 = rdcycle64(); i1 = rdinstret64();

    cpi_milli = ((c1 - c0) * 1000ull) / (i1 - i0);
    score_milli = ((unsigned long long)COREMARK_ITERS * CLK_HZ * 1000ull) / (c1 - c0);
    ee_printf("COREMARK_SUMMARY variant=%s cycles_lo=%u cycles_hi=%u inst_lo=%u inst_hi=%u cpi_milli=%u score_milli=%u\n",
              VARIANT_NAME, (uint32_t)(c1 - c0), (uint32_t)((c1 - c0) >> 32),
              (uint32_t)(i1 - i0), (uint32_t)((i1 - i0) >> 32),
              (uint32_t)cpi_milli, (uint32_t)score_milli);
    ee_printf("EP05 DONE variant=%s\n", VARIANT_NAME);

    while (1)
        __asm__ volatile ("wfi");
}
