vm_dispatch_compare.c

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#if !defined(SWITCH) && !defined(THREADING)
#error "Compile com -DSWITCH ou -DTHREADING."
#endif

#if defined(SWITCH) && defined(THREADING)
#error "Escolha apenas uma estrategia por compilacao."
#endif

#if defined(THREADING) && !defined(__GNUC__)
#error "THREADING depende de computed goto (GCC/Clang GNU mode)."
#endif

#ifndef ITERATIONS
#define ITERATIONS 20000000u
#endif

enum {
    OP_PUSH = 0,
    OP_ADD = 1,
    OP_SUB = 2,
    OP_LOAD = 3,
    OP_STORE = 4,
    OP_HALT = 5
};

typedef struct {
    uint64_t bytecodes;
    uint64_t dispatch_branches_modeled;
    uint64_t checksum;
    int32_t final_mem0;
    int32_t final_top;
} Metrics;

static __attribute__((noinline, noclone))
void build_program(int32_t *program) {
    program[0] = OP_PUSH;  program[1] = 10;
    program[2] = OP_PUSH;  program[3] = 20;
    program[4] = OP_ADD;
    program[5] = OP_PUSH;  program[6] = 5;
    program[7] = OP_SUB;
    program[8] = OP_STORE; program[9] = 0;
    program[10] = OP_LOAD; program[11] = 0;
    program[12] = OP_HALT;
}

static inline uint64_t modeled_switch_dispatch_cost(int32_t opcode) {
    switch (opcode) {
        case OP_PUSH:  return 1;
        case OP_ADD:   return 2;
        case OP_SUB:   return 3;
        case OP_LOAD:  return 4;
        case OP_STORE: return 5;
        case OP_HALT:  return 6;
        default:       return 0;
    }
}

#if defined(SWITCH)
static __attribute__((noinline, noclone))
Metrics run_switch(const int32_t *program, uint32_t iterations) {
    Metrics m = {0};

    for (uint32_t iter = 0; iter < iterations; ++iter) {
        const int32_t *ip = program;
        int32_t stack[8];
        int sp = 0;
        int32_t mem0 = 0;

        for (;;) {
            int32_t opcode = *ip++;
            m.bytecodes++;
            m.dispatch_branches_modeled += modeled_switch_dispatch_cost(opcode);

            switch (opcode) {
                case OP_PUSH:
                    stack[sp++] = *ip++;
                    break;

                case OP_ADD: {
                    int32_t rhs = stack[--sp];
                    int32_t lhs = stack[--sp];
                    stack[sp++] = lhs + rhs;
                    break;
                }

                case OP_SUB: {
                    int32_t rhs = stack[--sp];
                    int32_t lhs = stack[--sp];
                    stack[sp++] = lhs - rhs;
                    break;
                }

                case OP_LOAD: {
                    int32_t addr = *ip++;
                    if (addr != 0) {
                        fprintf(stderr, "Endereco invalido: %d\n", addr);
                        exit(1);
                    }
                    stack[sp++] = mem0;
                    break;
                }

                case OP_STORE: {
                    int32_t addr = *ip++;
                    if (addr != 0) {
                        fprintf(stderr, "Endereco invalido: %d\n", addr);
                        exit(1);
                    }
                    mem0 = stack[--sp];
                    break;
                }

                case OP_HALT:
                    m.final_mem0 = mem0;
                    m.final_top = stack[sp - 1];
                    m.checksum += (uint64_t)(uint32_t)(mem0 + stack[sp - 1]);
                    goto end_iteration;

                default:
                    fprintf(stderr, "Opcode invalido: %d\n", opcode);
                    exit(1);
            }
        }

end_iteration:
        ;
    }

    return m;
}

#endif

#if defined(THREADING)
static __attribute__((noinline, noclone))
Metrics run_threading(const int32_t *program, uint32_t iterations) {
    Metrics m = {0};

    for (uint32_t iter = 0; iter < iterations; ++iter) {
        const int32_t *ip = program;
        int32_t stack[8];
        int sp = 0;
        int32_t mem0 = 0;
        int32_t opcode;
        static void *dispatch_table[] = {
            &&do_push, &&do_add, &&do_sub, &&do_load, &&do_store, &&do_halt
        };

#define DISPATCH()                       \
        do {                            \
            opcode = *ip++;             \
            m.bytecodes++;              \
            m.dispatch_branches_modeled++; \
            goto *dispatch_table[opcode];  \
        } while (0)

        DISPATCH();

do_push:
        stack[sp++] = *ip++;
        DISPATCH();

do_add: {
        int32_t rhs = stack[--sp];
        int32_t lhs = stack[--sp];
        stack[sp++] = lhs + rhs;
        DISPATCH();
    }

do_sub: {
        int32_t rhs = stack[--sp];
        int32_t lhs = stack[--sp];
        stack[sp++] = lhs - rhs;
        DISPATCH();
    }

do_load: {
        int32_t addr = *ip++;
        if (addr != 0) {
            fprintf(stderr, "Endereco invalido: %d\n", addr);
            exit(1);
        }
        stack[sp++] = mem0;
        DISPATCH();
    }

do_store: {
        int32_t addr = *ip++;
        if (addr != 0) {
            fprintf(stderr, "Endereco invalido: %d\n", addr);
            exit(1);
        }
        mem0 = stack[--sp];
        DISPATCH();
    }

do_halt:
        m.final_mem0 = mem0;
        m.final_top = stack[sp - 1];
        m.checksum += (uint64_t)(uint32_t)(mem0 + stack[sp - 1]);

#undef DISPATCH
    }

    return m;
}
#endif

static void print_report(const Metrics *m) {
    puts("============================================================");
#if defined(SWITCH)
    puts("C benchmark - switch dispatch");
#else
    puts("C benchmark - direct threading");
#endif
    puts("============================================================");
    printf("ITERATIONS: %" PRIu32 "\n", (uint32_t)ITERATIONS);
    printf("Bytecodes executados: %" PRIu64 "\n", m->bytecodes);
    printf("Branches de dispatch modelados: %" PRIu64 "\n", m->dispatch_branches_modeled);
    printf("Resultado final mem[0]: %" PRId32 "\n", m->final_mem0);
    printf("Topo final da pilha: %" PRId32 "\n", m->final_top);
    printf("Checksum acumulado: %" PRIu64 "\n", m->checksum);
}

int main(void) {
    int32_t program[13];
    build_program(program);

#if defined(SWITCH)
    Metrics m = run_switch(program, ITERATIONS);
#else
    Metrics m = run_threading(program, ITERATIONS);
#endif

    print_report(&m);
    return 0;
}