@fairyhunter13/opentui-core 0.1.113 → 0.1.114

package/src/zig/bench-utils.zig

@@ -0,0 +1,431 @@
+const std = @import("std");
+
+pub fn matchesBenchFilter(bench_name: []const u8, filter: ?[]const u8) bool {
+    if (filter == null) return true;
+    const filter_str = filter.?;
+    if (filter_str.len == 0) return true;
+
+    var i: usize = 0;
+    while (i + filter_str.len <= bench_name.len) : (i += 1) {
+        var matches = true;
+        for (filter_str, 0..) |filter_char, j| {
+            const bench_char = bench_name[i + j];
+            const filter_lower = if (filter_char >= 'A' and filter_char <= 'Z') filter_char + 32 else filter_char;
+            const bench_lower = if (bench_char >= 'A' and bench_char <= 'Z') bench_char + 32 else bench_char;
+            if (filter_lower != bench_lower) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) return true;
+    }
+    return false;
+}
+
+pub const MemStat = struct {
+    name: []const u8,
+    bytes: usize,
+};
+
+pub const BenchResult = struct {
+    name: []const u8,
+    min_ns: u64,
+    avg_ns: u64,
+    max_ns: u64,
+    total_ns: u64,
+    iterations: usize,
+    mem_stats: ?[]const MemStat,
+};
+
+/// Timing statistics collected during benchmark iterations
+pub const BenchStats = struct {
+    min_ns: u64 = std.math.maxInt(u64),
+    max_ns: u64 = 0,
+    total_ns: u64 = 0,
+    count: usize = 0,
+
+    pub fn record(self: *BenchStats, elapsed_ns: u64) void {
+        self.min_ns = @min(self.min_ns, elapsed_ns);
+        self.max_ns = @max(self.max_ns, elapsed_ns);
+        self.total_ns += elapsed_ns;
+        self.count += 1;
+    }
+
+    pub fn avg(self: *const BenchStats) u64 {
+        if (self.count == 0) return 0;
+        return self.total_ns / self.count;
+    }
+};
+
+/// Helper for running benchmark iterations with timing
+pub const BenchRunner = struct {
+    allocator: std.mem.Allocator,
+    results: std.ArrayListUnmanaged(BenchResult),
+
+    pub fn init(allocator: std.mem.Allocator) BenchRunner {
+        return .{
+            .allocator = allocator,
+            .results = .{},
+        };
+    }
+
+    /// Add a benchmark result from collected stats
+    pub fn addResult(
+        self: *BenchRunner,
+        name: []const u8,
+        stats: BenchStats,
+        mem_stats: ?[]const MemStat,
+    ) !void {
+        try self.results.append(self.allocator, BenchResult{
+            .name = name,
+            .min_ns = stats.min_ns,
+            .avg_ns = stats.avg(),
+            .max_ns = stats.max_ns,
+            .total_ns = stats.total_ns,
+            .iterations = stats.count,
+            .mem_stats = mem_stats,
+        });
+    }
+
+    /// Convenience: run a simple benchmark with the given function
+    pub fn bench(
+        self: *BenchRunner,
+        name: []const u8,
+        iterations: usize,
+        comptime benchFn: anytype,
+        args: anytype,
+    ) !void {
+        var stats = BenchStats{};
+        var iter: usize = 0;
+        while (iter < iterations) : (iter += 1) {
+            var timer = try std.time.Timer.start();
+            @call(.auto, benchFn, args);
+            stats.record(timer.read());
+        }
+        try self.addResult(name, stats, null);
+    }
+
+    /// Get the results slice (caller owns memory via arena)
+    pub fn finish(self: *BenchRunner) ![]BenchResult {
+        return try self.results.toOwnedSlice(self.allocator);
+    }
+
+    /// Append results from another runner or slice
+    pub fn appendSlice(self: *BenchRunner, other_results: []const BenchResult) !void {
+        try self.results.appendSlice(self.allocator, other_results);
+    }
+};
+
+/// Create a stdout writer with buffer for benchmark output
+pub const StdoutWriter = struct {
+    buffer: [4096]u8 = undefined,
+    writer: std.fs.File.Writer = undefined,
+
+    pub fn init() StdoutWriter {
+        var self = StdoutWriter{};
+        self.writer = std.fs.File.stdout().writer(&self.buffer);
+        return self;
+    }
+
+    pub fn interface(self: *StdoutWriter) *std.Io.Writer {
+        return &self.writer.interface;
+    }
+
+    pub fn print(self: *StdoutWriter, comptime fmt: []const u8, args: anytype) !void {
+        try self.writer.interface.print(fmt, args);
+    }
+
+    pub fn flush(self: *StdoutWriter) !void {
+        try self.writer.interface.flush();
+    }
+};
+
+pub fn formatDuration(ns: u64) struct { value: f64, unit: []const u8, color: []const u8 } {
+    if (ns < 1_000) {
+        // Bright green for nanoseconds
+        return .{ .value = @as(f64, @floatFromInt(ns)), .unit = "ns", .color = "\x1b[92m" };
+    } else if (ns < 1_000_000) {
+        // Normal green for microseconds
+        return .{ .value = @as(f64, @floatFromInt(ns)) / 1_000.0, .unit = "us", .color = "\x1b[32m" };
+    } else if (ns < 1_000_000_000) {
+        const ms = @as(f64, @floatFromInt(ns)) / 1_000_000.0;
+        if (ms < 1.0) {
+            // Normal green for < 1ms
+            return .{ .value = ms, .unit = "ms", .color = "\x1b[32m" };
+        } else if (ms < 3.0) {
+            // Yellow to red gradient from 1ms to 3ms
+            if (ms < 1.5) {
+                return .{ .value = ms, .unit = "ms", .color = "\x1b[33m" }; // Yellow
+            } else if (ms < 2.0) {
+                return .{ .value = ms, .unit = "ms", .color = "\x1b[38;5;208m" }; // Orange
+            } else if (ms < 2.5) {
+                return .{ .value = ms, .unit = "ms", .color = "\x1b[38;5;202m" }; // Dark orange
+            } else {
+                return .{ .value = ms, .unit = "ms", .color = "\x1b[31m" }; // Red
+            }
+        } else {
+            // Full red for >= 3ms
+            return .{ .value = ms, .unit = "ms", .color = "\x1b[31m" };
+        }
+    } else {
+        // Red for seconds
+        return .{ .value = @as(f64, @floatFromInt(ns)) / 1_000_000_000.0, .unit = "s", .color = "\x1b[31m" };
+    }
+}
+
+pub fn formatBytes(bytes: usize) struct { value: f64, unit: []const u8 } {
+    if (bytes < 1024) {
+        return .{ .value = @as(f64, @floatFromInt(bytes)), .unit = "B" };
+    } else if (bytes < 1024 * 1024) {
+        return .{ .value = @as(f64, @floatFromInt(bytes)) / 1024.0, .unit = "KiB" };
+    } else {
+        return .{ .value = @as(f64, @floatFromInt(bytes)) / (1024.0 * 1024.0), .unit = "MiB" };
+    }
+}
+
+pub fn printResults(writer: anytype, results: []const BenchResult) !void {
+    if (results.len == 0) return;
+
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // Collect all unique memory stat names
+    var mem_stat_names: std.ArrayListUnmanaged([]const u8) = .{};
+    for (results) |result| {
+        if (result.mem_stats) |stats| {
+            for (stats) |stat| {
+                // Check if we already have this name
+                var found = false;
+                for (mem_stat_names.items) |existing_name| {
+                    if (std.mem.eql(u8, existing_name, stat.name)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    try mem_stat_names.append(allocator, stat.name);
+                }
+            }
+        }
+    }
+
+    // Calculate column widths
+    var max_name_len: usize = 20; // minimum
+    var min_col_width: usize = 3; // minimum for "Min"
+    var avg_col_width: usize = 3; // minimum for "Avg"
+    var max_col_width: usize = 3; // minimum for "Max"
+
+    // Create a map to store column widths for each memory stat
+    var mem_col_widths: std.ArrayListUnmanaged(usize) = .{};
+    for (mem_stat_names.items) |name| {
+        try mem_col_widths.append(allocator, name.len); // minimum is the name length
+    }
+
+    // First pass: calculate maximum widths
+    for (results) |result| {
+        if (result.name.len > max_name_len) {
+            max_name_len = result.name.len;
+        }
+
+        const min = formatDuration(result.min_ns);
+        const avg = formatDuration(result.avg_ns);
+        const max = formatDuration(result.max_ns);
+
+        var min_buf: [32]u8 = undefined;
+        const min_str = std.fmt.bufPrint(&min_buf, "{d:.2}{s}", .{ min.value, min.unit }) catch unreachable;
+        if (min_str.len > min_col_width) min_col_width = min_str.len;
+
+        var avg_buf: [32]u8 = undefined;
+        const avg_str = std.fmt.bufPrint(&avg_buf, "{d:.2}{s}", .{ avg.value, avg.unit }) catch unreachable;
+        if (avg_str.len > avg_col_width) avg_col_width = avg_str.len;
+
+        var max_buf: [32]u8 = undefined;
+        const max_str = std.fmt.bufPrint(&max_buf, "{d:.2}{s}", .{ max.value, max.unit }) catch unreachable;
+        if (max_str.len > max_col_width) max_col_width = max_str.len;
+
+        if (result.mem_stats) |stats| {
+            for (stats) |stat| {
+                const mem = formatBytes(stat.bytes);
+                var mem_buf: [32]u8 = undefined;
+                const mem_str = std.fmt.bufPrint(&mem_buf, "{d:.2} {s}", .{ mem.value, mem.unit }) catch unreachable;
+
+                // Find the index of this stat name
+                for (mem_stat_names.items, 0..) |name, i| {
+                    if (std.mem.eql(u8, name, stat.name)) {
+                        if (mem_str.len > mem_col_widths.items[i]) {
+                            mem_col_widths.items[i] = mem_str.len;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // Print header
+    var total_width = max_name_len + 3 + min_col_width + 3 + avg_col_width + 3 + max_col_width;
+    for (mem_col_widths.items) |width| {
+        total_width += 3 + width;
+    }
+    try writer.writeAll("\x1b[2m");
+    try writer.splatByteAll('-', total_width);
+    try writer.writeAll("\x1b[0m\n");
+
+    // Column headers
+    try writer.writeAll("\x1b[36m");
+    try writer.writeAll("Benchmark");
+    try writer.splatByteAll(' ', max_name_len - 9);
+    try writer.writeAll("\x1b[0m\x1b[2m | \x1b[0m");
+
+    try writer.writeAll("\x1b[36m");
+    try writer.writeAll("Min");
+    try writer.splatByteAll(' ', min_col_width - 3);
+    try writer.writeAll("\x1b[0m\x1b[2m | \x1b[0m");
+
+    try writer.writeAll("\x1b[36m");
+    try writer.writeAll("Avg");
+    try writer.splatByteAll(' ', avg_col_width - 3);
+    try writer.writeAll("\x1b[0m\x1b[2m | \x1b[0m");
+
+    try writer.writeAll("\x1b[36m");
+    try writer.writeAll("Max");
+    try writer.splatByteAll(' ', max_col_width - 3);
+    try writer.writeAll("\x1b[0m");
+
+    // Dynamic memory stat headers
+    for (mem_stat_names.items, 0..) |name, i| {
+        try writer.writeAll("\x1b[2m | \x1b[0m");
+        try writer.writeAll("\x1b[36m");
+        try writer.writeAll(name);
+        if (name.len < mem_col_widths.items[i]) {
+            try writer.splatByteAll(' ', mem_col_widths.items[i] - name.len);
+        }
+        try writer.writeAll("\x1b[0m");
+    }
+
+    try writer.writeByte('\n');
+
+    try writer.writeAll("\x1b[2m");
+    try writer.splatByteAll('-', total_width);
+    try writer.writeAll("\x1b[0m\n");
+
+    // Print each result
+    for (results, 0..) |result, row_idx| {
+        const min = formatDuration(result.min_ns);
+        const avg = formatDuration(result.avg_ns);
+        const max = formatDuration(result.max_ns);
+
+        // Format duration strings
+        var min_buf: [32]u8 = undefined;
+        const min_str = try std.fmt.bufPrint(&min_buf, "{d:.2}{s}", .{ min.value, min.unit });
+
+        var avg_buf: [32]u8 = undefined;
+        const avg_str = try std.fmt.bufPrint(&avg_buf, "{d:.2}{s}", .{ avg.value, avg.unit });
+
+        var max_buf: [32]u8 = undefined;
+        const max_str = try std.fmt.bufPrint(&max_buf, "{d:.2}{s}", .{ max.value, max.unit });
+
+        if (row_idx % 2 == 1) {
+            try writer.writeAll("\x1b[48;5;234m");
+        }
+
+        // Benchmark name
+        try writer.writeAll(result.name);
+        try writer.splatByteAll(' ', max_name_len - result.name.len);
+        try writer.writeAll("\x1b[2m | \x1b[0m");
+        if (row_idx % 2 == 1) {
+            try writer.writeAll("\x1b[48;5;234m");
+        }
+
+        // Min (right-aligned with color)
+        if (min_str.len < min_col_width) {
+            try writer.splatByteAll(' ', min_col_width - min_str.len);
+        }
+        try writer.writeAll(min.color);
+        try writer.writeAll(min_str);
+        try writer.writeAll("\x1b[0m");
+        try writer.writeAll("\x1b[2m | \x1b[0m");
+        if (row_idx % 2 == 1) {
+            try writer.writeAll("\x1b[48;5;234m");
+        }
+
+        // Avg (right-aligned with color)
+        if (avg_str.len < avg_col_width) {
+            try writer.splatByteAll(' ', avg_col_width - avg_str.len);
+        }
+        try writer.writeAll(avg.color);
+        try writer.writeAll(avg_str);
+        try writer.writeAll("\x1b[0m");
+        try writer.writeAll("\x1b[2m | \x1b[0m");
+        if (row_idx % 2 == 1) {
+            try writer.writeAll("\x1b[48;5;234m");
+        }
+
+        // Max (right-aligned with color)
+        if (max_str.len < max_col_width) {
+            try writer.splatByteAll(' ', max_col_width - max_str.len);
+        }
+        try writer.writeAll(max.color);
+        try writer.writeAll(max_str);
+        try writer.writeAll("\x1b[0m");
+
+        // Dynamic memory stats columns
+        for (mem_stat_names.items, 0..) |stat_name, i| {
+            try writer.writeAll("\x1b[2m | \x1b[0m");
+            if (row_idx % 2 == 1) {
+                try writer.writeAll("\x1b[48;5;234m");
+            }
+
+            // Look for this stat in the result's memory stats
+            var found_stat: ?usize = null;
+            if (result.mem_stats) |stats| {
+                for (stats) |stat| {
+                    if (std.mem.eql(u8, stat.name, stat_name)) {
+                        found_stat = stat.bytes;
+                        break;
+                    }
+                }
+            }
+
+            if (found_stat) |bytes| {
+                const mem = formatBytes(bytes);
+                var mem_buf: [32]u8 = undefined;
+                const mem_str = std.fmt.bufPrint(&mem_buf, "{d:.2} {s}", .{ mem.value, mem.unit }) catch unreachable;
+
+                // Right-aligned
+                if (mem_str.len < mem_col_widths.items[i]) {
+                    try writer.splatByteAll(' ', mem_col_widths.items[i] - mem_str.len);
+                }
+                try writer.writeAll(mem_str);
+            } else {
+                // Empty column
+                try writer.splatByteAll(' ', mem_col_widths.items[i]);
+            }
+        }
+
+        if (row_idx % 2 == 1) {
+            try writer.writeAll("\x1b[0m");
+        }
+        try writer.writeByte('\n');
+    }
+
+    try writer.writeAll("\x1b[2m");
+    try writer.splatByteAll('-', total_width);
+    try writer.writeAll("\x1b[0m\n");
+    try writer.flush();
+}
+
+const BenchResultsJson = struct {
+    benchmark: []const u8,
+    results: []const BenchResult,
+};
+
+pub fn printResultsJson(writer: anytype, results: []const BenchResult, bench_name: []const u8) !void {
+    const output = BenchResultsJson{
+        .benchmark = bench_name,
+        .results = results,
+    };
+    try std.json.Stringify.value(output, .{ .emit_null_optional_fields = false }, writer);
+    try writer.writeByte('\n');
+}

package/src/zig/bench.zig

@@ -0,0 +1,217 @@
+// Benchmark Runner CLI
+//
+// This is the main entry point for running performance benchmarks for opentui core components.
+//
+// Usage:
+//   zig build bench              - Run all benchmarks
+//   zig build bench -- --help    - Show help message with available options
+//
+// Options:
+//   --mem                   Show memory statistics after each benchmark
+//   --filter, -f NAME       Run only benchmark categories matching NAME (case-insensitive substring)
+//   --bench, -b NAME        Run only specific benchmarks matching NAME
+//   --json                  Output results in JSON format (machine-readable)
+//   --help, -h              Display help message and list available benchmarks
+//
+// Examples:
+//   zig build bench -- --mem
+//     Run all benchmarks with memory statistics
+//
+//   zig build bench -- --filter rope
+//     Run only benchmarks with "rope" in their name (Rope Data Structure, Rope Marker Tracking)
+//
+//   zig build bench -- -f textbuffer --mem
+//     Run TextBuffer benchmarks with memory statistics
+//
+//   zig build bench -- --filter "edit"
+//     Run EditBuffer Operations benchmarks
+//
+//   zig build bench -- --bench "ASCII"
+//     Run only benchmarks with "ASCII" in their name
+//
+//   zig build bench -- --json
+//     Output results in JSON format for CI integration
+//
+// Adding New Benchmarks:
+//   1. Create a new file in bench/ directory (e.g., bench/my_bench.zig)
+//   2. Export `pub const benchName = "My Benchmark";`
+//   3. Export `pub fn run(allocator: std.mem.Allocator, show_mem: bool, bench_filter: ?[]const u8) ![]BenchResult`
+//   4. Import the module at the top of this file
+//   5. Add an entry to the `benchmarks` array in main() with your module
+
+const std = @import("std");
+const bench_utils = @import("bench-utils.zig");
+const gp = @import("grapheme.zig");
+
+// Import all benchmark modules
+const text_buffer_view_bench = @import("bench/text-buffer-view_bench.zig");
+const edit_buffer_bench = @import("bench/edit-buffer_bench.zig");
+const rope_bench = @import("bench/rope_bench.zig");
+const rope_markers_bench = @import("bench/rope-markers_bench.zig");
+const text_buffer_coords_bench = @import("bench/text-buffer-coords_bench.zig");
+const styled_text_bench = @import("bench/styled-text_bench.zig");
+const buffer_draw_text_buffer_bench = @import("bench/buffer-draw-text-buffer_bench.zig");
+const utf8_bench = @import("bench/utf8_bench.zig");
+const text_chunk_graphemes_bench = @import("bench/text-chunk-graphemes_bench.zig");
+
+const BenchModule = struct {
+    name: []const u8,
+    run: *const fn (std.mem.Allocator, bool, ?[]const u8) anyerror![]bench_utils.BenchResult,
+};
+
+fn matchesFilter(bench_name: []const u8, filter: ?[]const u8) bool {
+    if (filter == null) return true;
+    const filter_str = filter.?;
+    if (filter_str.len == 0) return true;
+
+    var i: usize = 0;
+    while (i + filter_str.len <= bench_name.len) : (i += 1) {
+        var matches = true;
+        for (filter_str, 0..) |filter_char, j| {
+            const bench_char = bench_name[i + j];
+            const filter_lower = if (filter_char >= 'A' and filter_char <= 'Z') filter_char + 32 else filter_char;
+            const bench_lower = if (bench_char >= 'A' and bench_char <= 'Z') bench_char + 32 else bench_char;
+            if (filter_lower != bench_lower) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches) return true;
+    }
+    return false;
+}
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Initialize global pool and unicode data ONCE with base GPA allocator
+    // This ensures they persist across all benchmarks (even with arena allocators)
+    _ = gp.initGlobalPool(allocator);
+    defer gp.deinitGlobalPool();
+
+    const benchmarks = [_]BenchModule{
+        .{ .name = text_buffer_view_bench.benchName, .run = text_buffer_view_bench.run },
+        .{ .name = edit_buffer_bench.benchName, .run = edit_buffer_bench.run },
+        .{ .name = rope_bench.benchName, .run = rope_bench.run },
+        .{ .name = rope_markers_bench.benchName, .run = rope_markers_bench.run },
+        .{ .name = text_buffer_coords_bench.benchName, .run = text_buffer_coords_bench.run },
+        .{ .name = styled_text_bench.benchName, .run = styled_text_bench.run },
+        .{ .name = buffer_draw_text_buffer_bench.benchName, .run = buffer_draw_text_buffer_bench.run },
+        .{ .name = utf8_bench.benchName, .run = utf8_bench.run },
+        .{ .name = text_chunk_graphemes_bench.benchName, .run = text_chunk_graphemes_bench.run },
+    };
+
+    const args = try std.process.argsAlloc(allocator);
+    defer std.process.argsFree(allocator, args);
+
+    var show_mem = false;
+    var json_output = false;
+    var filter: ?[]const u8 = null;
+    var bench_filter: ?[]const u8 = null;
+    var i: usize = 1;
+    while (i < args.len) : (i += 1) {
+        const arg = args[i];
+        if (std.mem.eql(u8, arg, "--mem")) {
+            show_mem = true;
+        } else if (std.mem.eql(u8, arg, "--json")) {
+            json_output = true;
+        } else if (std.mem.eql(u8, arg, "--filter") or std.mem.eql(u8, arg, "-f")) {
+            if (i + 1 < args.len) {
+                i += 1;
+                filter = args[i];
+            }
+        } else if (std.mem.eql(u8, arg, "--bench") or std.mem.eql(u8, arg, "-b")) {
+            if (i + 1 < args.len) {
+                i += 1;
+                bench_filter = args[i];
+            }
+        } else if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
+            var stdout_buffer: [4096]u8 = undefined;
+            var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+            const stdout = &stdout_writer.interface;
+            try stdout.print("Usage: bench [options]\n\n", .{});
+            try stdout.print("Options:\n", .{});
+            try stdout.print("  --mem                   Show memory statistics\n", .{});
+            try stdout.print("  --json                  Output in JSON format (machine-readable)\n", .{});
+            try stdout.print("  --filter, -f NAME       Run only benchmark categories matching NAME\n", .{});
+            try stdout.print("  --bench, -b NAME        Run only specific benchmarks matching NAME\n", .{});
+            try stdout.print("  --help, -h              Show this help message\n\n", .{});
+            try stdout.print("Available benchmarks:\n", .{});
+            for (benchmarks) |bench| {
+                try stdout.print("  - {s}\n", .{bench.name});
+            }
+            try stdout.flush();
+            return;
+        }
+    }
+
+    var stdout_buffer: [4096]u8 = undefined;
+    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    const stdout = &stdout_writer.interface;
+
+    if (!json_output and filter != null) {
+        try stdout.print("Filtering benchmarks by: \"{s}\"\n", .{filter.?});
+    }
+    if (!json_output and bench_filter != null) {
+        try stdout.print("Filtering individual benchmarks by: \"{s}\"\n", .{bench_filter.?});
+    }
+
+    var ran_any = false;
+
+    for (benchmarks) |bench| {
+        if (!matchesFilter(bench.name, filter)) continue;
+
+        // Use arena for results only - benchmark modules manage their own temp memory
+        var results_arena = std.heap.ArenaAllocator.init(allocator);
+        defer results_arena.deinit();
+
+        const start_time = std.time.nanoTimestamp();
+        const results = try bench.run(results_arena.allocator(), show_mem, bench_filter);
+        const end_time = std.time.nanoTimestamp();
+        const elapsed_ns = end_time - start_time;
+
+        if (results.len == 0) continue;
+
+        if (!json_output) {
+            try stdout.print("\n=== {s} Benchmarks ===\n\n", .{bench.name});
+            try stdout.flush();
+        }
+
+        if (json_output) {
+            try bench_utils.printResultsJson(stdout, results, bench.name);
+        } else {
+            try bench_utils.printResults(stdout, results);
+            const elapsed_ms = @as(f64, @floatFromInt(elapsed_ns)) / 1_000_000.0;
+            try stdout.print("\n  Overall time: {d:.2}ms\n", .{elapsed_ms});
+        }
+
+        ran_any = true;
+    }
+
+    if (!ran_any) {
+        if (!json_output) {
+            if (filter != null and bench_filter != null) {
+                try stdout.print(
+                    "\nNo benchmarks matched filters: category=\"{s}\", bench=\"{s}\"\n",
+                    .{ filter.?, bench_filter.? },
+                );
+            } else if (bench_filter != null) {
+                try stdout.print("\nNo benchmarks matched bench filter: \"{s}\"\n", .{bench_filter.?});
+            } else if (filter != null) {
+                try stdout.print("\nNo benchmarks matched filter: \"{s}\"\n", .{filter.?});
+            } else {
+                try stdout.print("\nNo benchmarks ran.\n", .{});
+            }
+            try stdout.print("Use --help to see available benchmarks.\n", .{});
+        }
+        try stdout.flush();
+        return;
+    }
+
+    if (!json_output) {
+        try stdout.print("\n✓ Benchmarks complete\n", .{});
+    }
+    try stdout.flush();
+}