008 event taps overhead

○ Planned This feature is planned but not yet implemented.

Event tap code injection not yet implemented

Failure Output

Showing last 10 of 41 lines

 45 | ~count -> * | next n where n.i % 200_004 == 0 |> tap-point(n.i) | done |> _
    | ^
  hint: '_' has meaning only as `| branch [binding] |> _`. Chaining `|> _` after another step is meaningless — drop the `|> _`.

error[KORU010]: '_' is only legal as the sole body of a branch handler
  --> tests/regression/400_RUNTIME_FEATURES/420_PERFORMANCE/420_008_event_taps_overhead/input.kz:49:0
    |
 49 | |> print-result() | done |> _
    | ^
  hint: '_' has meaning only as `| branch [binding] |> _`. Chaining `|> _` after another step is meaningless — drop the `|> _`.

Code

// PERFORMANCE TEST: Event taps overhead vs manual instrumentation
// Goal: Prove taps have same cost as manual function calls
// Loop 1 million times with 5 tap points
// Baseline: Zig with manual function calls at same points
// Threshold: 1.05x (5% slower max)

const std = @import("std");

// Counter for tap calls (verify taps actually run)
var tap_count: u64 = 0;

// Event for loop iteration
~tor count { i: u64 } -> u64

~proc count|zig {
    if (i < 1_000_000) {
        return i + 1;
    } else {
    }
}

// Tap target - simulates logging/metrics
~tor tap-point { i: u64 }

~proc tap-point|zig {
    tap_count += 1;
    // Touch parameter to avoid unused warning
    if (i > 999_999_999) {
        std.debug.print("Impossible\n", .{});
    }
}

// Print result
~tor print-result {}

~proc print-result|zig {
    std.debug.print("Taps called: {}\n", .{tap_count});
}

// Taps: Observe every 5th iteration (5 tap points)
~count -> * | next n where n.i % 200_000 == 0 |> tap-point(n.i) | done |> _
~count -> * | next n where n.i % 200_001 == 0 |> tap-point(n.i) | done |> _
~count -> * | next n where n.i % 200_002 == 0 |> tap-point(n.i) | done |> _
~count -> * | next n where n.i % 200_003 == 0 |> tap-point(n.i) | done |> _
~count -> * | next n where n.i % 200_004 == 0 |> tap-point(n.i) | done |> _

// Main loop
~#loop count(i: 0): n |> @loop(n.i)
|> print-result() | done |> _

input.kz

Test Configuration

MUST_RUN

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:           ${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

← 007 simple loop 009 multi consumer async →