components/BenchUtiliz/src/benchUtiliz.c

/*
 * Copyright 2020, Data61, CSIRO (ABN 41 687 119 230)
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <limits.h>
#include <autoconf.h>
#include <camkes.h>
#include <stdio.h>
#include <sel4bench/sel4bench.h>
#include <camkes/tls.h>
#include <sel4/benchmark_utilisation_types.h>

#define MAGIC_CYCLES 150

struct {
    uint32_t head;
    uint32_t tail;
    char buf[0x1000];
} extern WEAK volatile *serial_getchar_buf;
WEAK seL4_CPtr serial_getchar_notification(void);
volatile bool flag = 0;

uint64_t ccount = 0;
uint64_t prev, start, ts, overflows;
uint64_t idle_ccount_start;
uint64_t idle_overflow_start;

void getchar_handler(void)
{
    seL4_Word badge;
    uint64_t total, kernel, idle;
    while (1) {
        seL4_Wait(serial_getchar_notification(), &badge);
        char ch = serial_getchar_buf->buf[serial_getchar_buf->head];
        serial_getchar_buf->head = (serial_getchar_buf->head + 1) % sizeof(serial_getchar_buf->buf);
        switch (ch) {
        case 'a':
            idle_start();
            break;
        case 'b':
            idle_stop(&total, &kernel, &idle);
            printf("{\n");
            printf("\"total\": %"PRIu64",\n", total);
            printf("\"kernel\": %"PRIu64",\n", kernel);
            printf("\"idle\": %"PRIu64"\n", idle);
            printf("}\n", idle);
            break;
        default:
            break;
        }
    }
}


void idle_start(void)
{
    if (!flag) {
        flag = 1;
        printf("Measurment starting...\n");
        trace_start_emit();
#ifdef CONFIG_BENCHMARK_TRACK_UTILISATION
        seL4_BenchmarkResetAllThreadsUtilisation();
        seL4_BenchmarkResetLog();
#endif

        start = (uint64_t)sel4bench_get_cycle_count();
        idle_ccount_start = ccount;
        idle_overflow_start = overflows;

    }
}


void idle_stop(uint64_t *total_ret, uint64_t *kernel_ret, uint64_t *idle_ret)
{
    flag = 0;
    uint64_t total = ((uint64_t)sel4bench_get_cycle_count()) - start;
    if ((overflows - idle_overflow_start) > 0) {
        ZF_LOGE("Cycle counter overflowed during measurement. Stats may not be accurate");
    }
    total += ULONG_MAX * (overflows - idle_overflow_start);
    uint64_t idle_total = ccount - idle_ccount_start;
#ifdef CONFIG_BENCHMARK_TRACK_UTILISATION
    seL4_BenchmarkFinalizeLog();

    seL4_BenchmarkGetThreadUtilisation(camkes_get_tls()->tcb_cap);
    uint64_t *buffer = (uint64_t *)&seL4_GetIPCBuffer()->msg[0];
    seL4_BenchmarkDumpAllThreadsUtilisation();
    *kernel_ret = buffer[BENCHMARK_TOTAL_KERNEL_UTILISATION];
#else
    *kernel_ret = 0;
#endif
    *total_ret = total;
    *idle_ret = idle_total;
    trace_stop_emit();
}


void count_idle(UNUSED void *arg)
{
    prev = sel4bench_get_cycle_count();
    ccount = 0;
    overflows = 0;

    while (1) {
        ts = (uint64_t)sel4bench_get_cycle_count();
        uint64_t diff;

        /* Handle overflow: This thread needs to run at least 2 times
           within any ULONG_MAX cycles period to detect overflows.
           This also assumes that the cycle counter overflows every ULONG_MAX
           cycles which may not be true for all platforms.*/
        if (ts < prev) {
            diff = ULONG_MAX - prev + ts + 1;
            overflows++;
        } else {
            diff = ts - prev;
        }

        if (diff < MAGIC_CYCLES) {
            COMPILER_MEMORY_FENCE();
            ccount += diff;
            COMPILER_MEMORY_FENCE();
        }
        prev = ts;
    }
}

void pre_init(void)
{
    sel4bench_init();
    int err = bench_to_reg_callback(&count_idle, NULL);
    if (err) {
        ZF_LOGE("Failed to register callback handler");
    }
    bench_from_emit();

    if (serial_putchar_putchar) {
        set_putchar(serial_putchar_putchar);
    }
}

int run(void)
{
    if (&serial_getchar_buf) {
        getchar_handler();
    }

    return 0;
}