○
Planned This feature is planned but not yet implemented.
Feature: Loop optimization with work distribution
Code
// PERFORMANCE TEST: Loop Optimization - Loop With Work Body
// Goal: Prove compiler inlines work event body into optimized loop
// Pattern: Checker event + work event called in label jump continuation
// Baseline: Hand-written Zig for loop with inlined work
// Threshold: 1.05x (5% overhead max)
//
// This tests WORK BODY INLINING:
// - Checker event controls loop flow
// - Work event performs computation
// - Optimizer should inline work event body into loop
// - Result: Single tight loop with no event dispatch overhead
const std = @import("std");
// Work event: Process array element (this should be INLINED into loop body)
~tor process-element { array: []u64, i: u64, sum: u64 } -> u64
~proc process-element|zig {
// Simulate some work: square the element and add to sum
const value = array[i];
const squared = value * value;
const new_sum = sum + squared;
return new_sum;
}
// Checker event: Loop through array indices
~tor loop-step { i: u64, limit: u64, sum: u64 }
| continue { i: u64, sum: u64 }
| done u64
~proc loop-step|zig {
if (i < limit) {
return .{ .continue = .{ .i = i, .sum = sum } };
} else {
return .{ .done = sum };
}
}
// Print result
~tor print { result: u64 }
~proc print|zig {
std.debug.print("Sum: {}\n", .{result});
}
// Initialize array event
~tor init-array {} -> []u64
~proc init-array|zig {
// Create array 0..10000
const allocator = std.heap.page_allocator;
const array = allocator.alloc(u64, 10_000) catch unreachable;
var i: u64 = 0;
while (i < 10_000) : (i += 1) {
array[i] = i;
}
return array;
}
// Main flow: Loop with work body
// Pattern the optimizer should detect:
// - Checker event controls loop (i from 0 to limit)
// - Work event is called in the continue branch
// - Work result flows to recursive jump
//
// Expected transformation:
// for (0..array.len) |i| {
// const value = array[i];
// const squared = value * value;
// sum += squared; // Work body INLINED here!
// }
~init-array(): init |> #work_loop loop-step(i: 0, limit: init.array.len, sum: 0)
| continue c |> process-element(init.array, c.i, c.sum): p |> @work_loop(i: c.i + 1, limit: init.array.len, p.sum)
| done d |> print(d.result)
Supporting Files
// Hand-written Zig baseline for loop with work body optimization test
// This is what the Koru optimizer SHOULD generate with work event inlined
const std = @import("std");
pub fn main() !void {
const allocator = std.heap.page_allocator;
const array = try allocator.alloc(u64, 10_000);
defer allocator.free(array);
// Initialize array
var i: u64 = 0;
while (i < 10_000) : (i += 1) {
array[i] = i;
}
// Process loop with inlined work body
var sum: u64 = 0;
for (array) |value| {
const squared = value * value;
sum += squared;
}
std.debug.print("Sum: {}\n", .{sum});
}
#!/bin/bash
# Benchmark: Loop Optimization - Basic Checker Event Pattern
# Compare Koru optimized loop vs hand-written Zig for loop
set -e
echo "Building baseline (Zig)..."
zig build-exe baseline.zig -O ReleaseFast
echo "Building Koru version..."
# Assuming output_emitted.zig or output exists from test runner
if [ -f "output_emitted.zig" ]; then
zig build-exe output_emitted.zig -O ReleaseFast -femit-bin=koru_output
elif [ -f "output" ]; then
# Already compiled, copy it
cp output koru_output
chmod +x koru_output
else
echo "ERROR: No Koru output found (output_emitted.zig or output)"
exit 1
fi
echo ""
echo "Running benchmarks with hyperfine..."
# Check if hyperfine is installed
if ! command -v hyperfine &> /dev/null; then
echo "ERROR: hyperfine not installed"
echo "Install with: brew install hyperfine (macOS) or cargo install hyperfine"
exit 1
fi
# Run benchmark
# Use --shell=none to avoid shell startup overhead
# Use more runs for better statistics on fast benchmarks
hyperfine --warmup 5 --runs 30 --shell=none \
--export-json results.json \
--command-name "Baseline (Zig)" './baseline' \
--command-name "Koru (Optimized)" './koru_output'
echo ""
echo "Benchmark complete! Results saved to results.json"
Flows
flow ~init-array click a branch to expand · @labels scroll to their anchor
init-array
Test Configuration
MUST_RUN THRESHOLD 1.05
Post-validation Script:
#!/bin/bash
# Post-validation: Check performance is within threshold
set -e
if [ ! -f "results.json" ]; then
echo "⚠️ No benchmark results found (results.json missing)"
echo " Running benchmark..."
bash benchmark.sh
fi
if [ ! -f "results.json" ]; then
echo "❌ FAIL: Benchmark did not produce results.json"
exit 1
fi
# Check if jq is installed
if ! command -v jq &> /dev/null; then
echo "⚠️ jq not installed (needed to parse benchmark results)"
echo " Install with: brew install jq (macOS) or apt install jq (Linux)"
echo " Skipping performance validation..."
exit 0
fi
THRESHOLD=$(cat THRESHOLD)
# Parse results (hyperfine format)
BASELINE_TIME=$(jq -r '.results[0].mean' results.json)
KORU_TIME=$(jq -r '.results[1].mean' results.json)
# Calculate ratio (Koru / Baseline)
RATIO=$(echo "scale=4; $KORU_TIME / $BASELINE_TIME" | bc -l)
echo ""
echo "Performance Results:"
echo " Baseline (Zig): ${BASELINE_TIME}s"
echo " Koru (Optimized): ${KORU_TIME}s"
echo " Ratio: ${RATIO}x"
echo " Threshold: ${THRESHOLD}x"
echo ""
# Compare to threshold
if (( $(echo "$RATIO > $THRESHOLD" | bc -l) )); then
echo "❌ PERFORMANCE REGRESSION!"
echo " Koru is ${RATIO}x slower than baseline"
echo " Threshold is ${THRESHOLD}x"
echo " Regression: $(echo "scale=1; ($RATIO - 1) * 100" | bc -l)%"
exit 1
elif (( $(echo "$RATIO < 0.95" | bc -l) )); then
echo "✅ PERFORMANCE IMPROVED!"
echo " Koru is FASTER than baseline (${RATIO}x)"
else
echo "✅ Performance within threshold"
echo " Overhead: $(echo "scale=1; ($RATIO - 1) * 100" | bc -l)%"
fi
exit 0