benchmark.tc

TinyC VM Benchmark

Source on GitHub

// TinyC VM Benchmark
// Measures execution speed of various operations
// Reports results via WebCall/JsonCall and serial output

int t_start = 0;
int t_int = 0;
int t_float = 0;
int t_array = 0;
int t_call = 0;
int t_string = 0;
int t_total = 0;

// ── Integer arithmetic benchmark ──
int bench_int() {
    int sum = 0;
    int i = 0;
    while (i < 100000) {
        sum = sum + i;
        sum = sum - (i / 2);
        sum = sum * 3;
        sum = sum / 4;
        sum = sum % 1000000;
        i++;
    }
    return sum;
}

// ── Float arithmetic benchmark ──
float bench_float() {
    float sum = 0.0;
    float x = 1.0;
    int i = 0;
    while (i < 50000) {
        sum = sum + x;
        x = x * 1.0001;
        sum = sum - x * 0.5;
        sum = sum * 1.001;
        sum = sum / 1.001;
        i++;
    }
    return sum;
}

// ── Array access benchmark ──
int bench_array() {
    int arr[200];
    int i = 0;
    // Fill
    while (i < 200) {
        arr[i] = i * 7;
        i++;
    }
    // Random-ish access pattern
    int sum = 0;
    i = 0;
    while (i < 100000) {
        int idx = (i * 31 + 17) % 200;
        sum = sum + arr[idx];
        arr[idx] = sum & 0xFFFF;
        i++;
    }
    return sum;
}

// ── Function call benchmark ──
int add3(int a, int b, int c) {
    return a + b + c;
}

int bench_call() {
    int sum = 0;
    int i = 0;
    while (i < 100000) {
        sum = add3(sum, i, 1);
        sum = sum & 0x7FFFFFFF;
        i++;
    }
    return sum;
}

// ── String operations benchmark ──
int bench_string() {
    char a[32];
    char b[32];
    char c[80];
    int i = 0;
    while (i < 10000) {
        strcpy(a, "Hello");
        strcpy(b, "World");
        strcpy(c, a);
        strcat(c, " ");
        strcat(c, b);
        int len = strlen(c);
        i++;
    }
    return i;
}

void WebCall() {
    char buf[64];
    sprintf(buf, "{s}Benchmark{m}%d ms total{e}", t_total);
    webSend(buf);
    sprintf(buf, "{s} Integer{m}%d ms{e}", t_int);
    webSend(buf);
    sprintf(buf, "{s} Float{m}%d ms{e}", t_float);
    webSend(buf);
    sprintf(buf, "{s} Array{m}%d ms{e}", t_array);
    webSend(buf);
    sprintf(buf, "{s} Calls{m}%d ms{e}", t_call);
    webSend(buf);
    sprintf(buf, "{s} Strings{m}%d ms{e}", t_string);
    webSend(buf);
}

void JsonCall() {
    char buf[128];
    sprintf(buf, ",\"Bench\":{\"Total\":%d", t_total);
    responseAppend(buf);
    sprintf(buf, ",\"Int\":%d", t_int);
    responseAppend(buf);
    sprintf(buf, ",\"Float\":%d", t_float);
    responseAppend(buf);
    sprintf(buf, ",\"Array\":%d", t_array);
    responseAppend(buf);
    sprintf(buf, ",\"Call\":%d", t_call);
    responseAppend(buf);
    sprintf(buf, ",\"Str\":%d}", t_string);
    responseAppend(buf);
}

int main() {
    char buf[64];
    int t0 = 0;
    int t1 = 0;

    printStr("=== TinyC Benchmark ===\n");

    t_start = millis();

    // 1. Integer arithmetic: 100k iterations, 5 ops each = 500k ops
    t0 = millis();
    bench_int();
    t1 = millis();
    t_int = t1 - t0;
    sprintf(buf, "Integer:  %d ms  (500k ops)\n", t_int);
    printString(buf);

    // 2. Float arithmetic: 50k iterations, 5 ops each = 250k ops
    t0 = millis();
    bench_float();
    t1 = millis();
    t_float = t1 - t0;
    sprintf(buf, "Float:    %d ms  (250k ops)\n", t_float);
    printString(buf);

    // 3. Array access: 200 fill + 100k random access
    t0 = millis();
    bench_array();
    t1 = millis();
    t_array = t1 - t0;
    sprintf(buf, "Array:    %d ms  (100k access)\n", t_array);
    printString(buf);

    // 4. Function calls: 100k calls with 3 args
    t0 = millis();
    bench_call();
    t1 = millis();
    t_call = t1 - t0;
    sprintf(buf, "Calls:    %d ms  (100k calls)\n", t_call);
    printString(buf);

    // 5. String operations: 10k iterations
    t0 = millis();
    bench_string();
    t1 = millis();
    t_string = t1 - t0;
    sprintf(buf, "Strings:  %d ms  (10k iters)\n", t_string);
    printString(buf);

    t_total = millis() - t_start;
    sprintf(buf, "── Total: %d ms ──\n", t_total);
    printString(buf);

    return 0;
}