@fairyhunter13/opentui-core 0.1.89 → 0.1.91

package/src/zig/bench/edit-buffer_bench.zig

@@ -0,0 +1,476 @@
+const std = @import("std");
+const bench_utils = @import("../bench-utils.zig");
+const edit_buffer = @import("../edit-buffer.zig");
+const gp = @import("../grapheme.zig");
+const link = @import("../link.zig");
+
+const EditBuffer = edit_buffer.EditBuffer;
+const BenchResult = bench_utils.BenchResult;
+const BenchStats = bench_utils.BenchStats;
+const MemStat = bench_utils.MemStat;
+
+pub const benchName = "EditBuffer Operations";
+
+fn benchInsertOperations(
+    allocator: std.mem.Allocator,
+    pool: *gp.GraphemePool,
+    iterations: usize,
+    show_mem: bool,
+    bench_filter: ?[]const u8,
+) ![]BenchResult {
+    var results: std.ArrayListUnmanaged(BenchResult) = .{};
+    errdefer results.deinit(allocator);
+    const link_pool = link.initGlobalLinkPool(allocator);
+
+    // Single-line insert at start
+    {
+        const name = "EditBuffer insert 1k times at start";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                const text = "Hello, world! ";
+                var timer = try std.time.Timer.start();
+                for (0..1000) |_| {
+                    try eb.insertText(text);
+                    try eb.setCursor(0, 0);
+                }
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    // Multi-line insert
+    {
+        const name = "EditBuffer insert 500 multi-line blocks";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                const text = "Line 1\nLine 2\nLine 3\n";
+                var timer = try std.time.Timer.start();
+                for (0..500) |_| {
+                    try eb.insertText(text);
+                }
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    return try results.toOwnedSlice(allocator);
+}
+
+fn benchDeleteOperations(
+    allocator: std.mem.Allocator,
+    pool: *gp.GraphemePool,
+    iterations: usize,
+    show_mem: bool,
+    bench_filter: ?[]const u8,
+) ![]BenchResult {
+    var results: std.ArrayListUnmanaged(BenchResult) = .{};
+    errdefer results.deinit(allocator);
+    const link_pool = link.initGlobalLinkPool(allocator);
+
+    // Single-line delete with backspace
+    {
+        const name = "EditBuffer backspace 500 chars";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                // Build up text
+                const text = "Hello, world! ";
+                for (0..1000) |_| {
+                    try eb.insertText(text);
+                }
+
+                var timer = try std.time.Timer.start();
+                for (0..500) |_| {
+                    try eb.backspace();
+                }
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    // Multi-line delete range
+    {
+        const name = "EditBuffer delete 50-line range";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                // Build up text with many lines
+                const text = "Line 1\nLine 2\nLine 3\n";
+                for (0..100) |_| {
+                    try eb.insertText(text);
+                }
+
+                var timer = try std.time.Timer.start();
+                // Delete across 50 lines
+                try eb.deleteRange(.{ .row = 10, .col = 0 }, .{ .row = 60, .col = 0 });
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    return try results.toOwnedSlice(allocator);
+}
+
+fn benchMixedOperations(
+    allocator: std.mem.Allocator,
+    pool: *gp.GraphemePool,
+    iterations: usize,
+    show_mem: bool,
+    bench_filter: ?[]const u8,
+) ![]BenchResult {
+    var results: std.ArrayListUnmanaged(BenchResult) = .{};
+    errdefer results.deinit(allocator);
+    const link_pool = link.initGlobalLinkPool(allocator);
+
+    // Simulated typing session
+    {
+        const name = "EditBuffer mixed operations (300 lines)";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                var timer = try std.time.Timer.start();
+
+                // Type some text
+                for (0..100) |_| {
+                    try eb.insertText("function test() {\n");
+                    try eb.insertText("    return 42;\n");
+                    try eb.insertText("}\n");
+                }
+
+                // Navigate and edit
+                try eb.setCursor(50, 0);
+                try eb.insertText("// Comment\n");
+
+                // Delete a range
+                try eb.deleteRange(.{ .row = 100, .col = 0 }, .{ .row = 120, .col = 0 });
+
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    return try results.toOwnedSlice(allocator);
+}
+
+fn benchWordBoundaryOperations(
+    allocator: std.mem.Allocator,
+    pool: *gp.GraphemePool,
+    iterations: usize,
+    show_mem: bool,
+    bench_filter: ?[]const u8,
+) ![]BenchResult {
+    var results: std.ArrayListUnmanaged(BenchResult) = .{};
+    errdefer results.deinit(allocator);
+    const link_pool = link.initGlobalLinkPool(allocator);
+
+    // Next word boundary navigation
+    {
+        const name = "EditBuffer getNextWordBoundary 1k times";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                // Build text with many words
+                const text = "The quick brown fox jumps over the lazy dog. ";
+                for (0..100) |_| {
+                    try eb.insertText(text);
+                }
+
+                try eb.setCursor(0, 0);
+
+                var timer = try std.time.Timer.start();
+                // Navigate through 1000 word boundaries
+                for (0..1000) |_| {
+                    const cursor = eb.getNextWordBoundary();
+                    try eb.setCursor(cursor.row, cursor.col);
+                }
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    // Previous word boundary navigation
+    {
+        const name = "EditBuffer getPrevWordBoundary 1k times";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                // Build text with many words
+                const text = "The quick brown fox jumps over the lazy dog. ";
+                for (0..100) |_| {
+                    try eb.insertText(text);
+                }
+
+                // Start at end
+                const line_count = eb.getTextBuffer().lineCount();
+                const last_line = if (line_count > 0) line_count - 1 else 0;
+                try eb.setCursor(last_line, 4500);
+
+                var timer = try std.time.Timer.start();
+                // Navigate backward through 1000 word boundaries
+                for (0..1000) |_| {
+                    const cursor = eb.getPrevWordBoundary();
+                    try eb.setCursor(cursor.row, cursor.col);
+                }
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    // Word boundary with multi-line text
+    {
+        const name = "EditBuffer word boundary multi-line 500 times";
+        if (bench_utils.matchesBenchFilter(name, bench_filter)) {
+            var stats = BenchStats{};
+            var final_mem: usize = 0;
+
+            for (0..iterations) |iter| {
+                var eb = try EditBuffer.init(allocator, pool, link_pool, .unicode);
+                defer eb.deinit();
+
+                // Build multi-line text with words
+                const text = "Hello world test\nAnother line here\nThird line content\n";
+                for (0..100) |_| {
+                    try eb.insertText(text);
+                }
+
+                try eb.setCursor(0, 0);
+
+                var timer = try std.time.Timer.start();
+                // Navigate through 500 word boundaries across lines
+                for (0..500) |_| {
+                    const cursor = eb.getNextWordBoundary();
+                    try eb.setCursor(cursor.row, cursor.col);
+                }
+                stats.record(timer.read());
+
+                if (iter == iterations - 1 and show_mem) {
+                    final_mem = eb.getTextBuffer().getArenaAllocatedBytes();
+                }
+            }
+
+            const mem_stats: ?[]const MemStat = if (show_mem) blk: {
+                const s = try allocator.alloc(MemStat, 1);
+                s[0] = .{ .name = "TB", .bytes = final_mem };
+                break :blk s;
+            } else null;
+
+            try results.append(allocator, BenchResult{
+                .name = name,
+                .min_ns = stats.min_ns,
+                .avg_ns = stats.avg(),
+                .max_ns = stats.max_ns,
+                .total_ns = stats.total_ns,
+                .iterations = iterations,
+                .mem_stats = mem_stats,
+            });
+        }
+    }
+
+    return try results.toOwnedSlice(allocator);
+}
+
+pub fn run(
+    allocator: std.mem.Allocator,
+    show_mem: bool,
+    bench_filter: ?[]const u8,
+) ![]BenchResult {
+    // Global pool and unicode data are initialized once in bench.zig
+    const pool = gp.initGlobalPool(allocator);
+
+    var all_results: std.ArrayListUnmanaged(BenchResult) = .{};
+    errdefer all_results.deinit(allocator);
+
+    const iterations: usize = 5;
+
+    // Run all benchmark categories and filter results
+    const insert_results = try benchInsertOperations(allocator, pool, iterations, show_mem, bench_filter);
+    try all_results.appendSlice(allocator, insert_results);
+
+    const delete_results = try benchDeleteOperations(allocator, pool, iterations, show_mem, bench_filter);
+    try all_results.appendSlice(allocator, delete_results);
+
+    const mixed_results = try benchMixedOperations(allocator, pool, iterations, show_mem, bench_filter);
+    try all_results.appendSlice(allocator, mixed_results);
+
+    const word_boundary_results = try benchWordBoundaryOperations(allocator, pool, iterations, show_mem, bench_filter);
+    try all_results.appendSlice(allocator, word_boundary_results);
+
+    return try all_results.toOwnedSlice(allocator);
+}

package/src/zig/bench/native-span-feed_bench.zig

@@ -0,0 +1,100 @@
+const std = @import("std");
+const raw = @import("../native-span-feed.zig");
+
+/// Zero-copy benchmark producer (reserve/commit).
+pub export fn benchProduce(
+    stream: ?*raw.Stream,
+    total_bytes: u64,
+    pattern_ptr: ?*const u8,
+    pattern_len: usize,
+    commit_every: u32,
+) callconv(.c) i32 {
+    if (stream == null) return raw.Status.err_invalid;
+    if (total_bytes == 0) return raw.Status.ok;
+
+    var pattern_slice: []const u8 = raw.default_pattern;
+    if (pattern_ptr != null and pattern_len > 0) {
+        pattern_slice = @as([*]const u8, @ptrCast(pattern_ptr.?))[0..pattern_len];
+    }
+    if (pattern_slice.len == 0) return raw.Status.err_invalid;
+
+    var remaining: u64 = total_bytes;
+    var reserve_info: raw.ReserveInfo = undefined;
+
+    while (remaining > 0) {
+        const remaining_usize = if (remaining > std.math.maxInt(usize))
+            std.math.maxInt(usize)
+        else
+            @as(usize, @intCast(remaining));
+
+        const reserve_status = raw.streamReserve(stream, 1, &reserve_info);
+        if (reserve_status != raw.Status.ok) return reserve_status;
+
+        const available: usize = @intCast(reserve_info.len);
+        const to_write = @min(available, remaining_usize);
+
+        const dest = @as([*]u8, @ptrFromInt(reserve_info.ptr))[0..to_write];
+        var dest_index: usize = 0;
+        while (dest_index < to_write) {
+            const copy_len = @min(pattern_slice.len, to_write - dest_index);
+            @memcpy(dest[dest_index .. dest_index + copy_len], pattern_slice[0..copy_len]);
+            dest_index += copy_len;
+        }
+
+        const commit_status = raw.streamCommitReserved(stream, @intCast(to_write));
+        if (commit_status != raw.Status.ok) return commit_status;
+
+        remaining -= @as(u64, to_write);
+    }
+
+    _ = commit_every;
+    return raw.Status.ok;
+}
+
+/// Copy benchmark producer (streamWrite).
+pub export fn benchProduceWrite(
+    stream: ?*raw.Stream,
+    total_bytes: u64,
+    pattern_ptr: ?*const u8,
+    pattern_len: usize,
+    commit_every: u32,
+) callconv(.c) i32 {
+    if (stream == null) return raw.Status.err_invalid;
+    if (total_bytes == 0) return raw.Status.ok;
+
+    var pattern_slice: []const u8 = raw.default_pattern;
+    if (pattern_ptr != null and pattern_len > 0) {
+        pattern_slice = @as([*]const u8, @ptrCast(pattern_ptr.?))[0..pattern_len];
+    }
+    if (pattern_slice.len == 0) return raw.Status.err_invalid;
+
+    var remaining: u64 = total_bytes;
+    var bytes_since_commit: u64 = 0;
+
+    while (remaining > 0) {
+        const remaining_usize = if (remaining > std.math.maxInt(usize))
+            std.math.maxInt(usize)
+        else
+            @as(usize, @intCast(remaining));
+
+        const to_write = @min(pattern_slice.len, remaining_usize);
+        const status = raw.streamWrite(stream, @ptrCast(pattern_slice.ptr), to_write);
+        if (status != raw.Status.ok) return status;
+
+        bytes_since_commit += @as(u64, to_write);
+        remaining -= @as(u64, to_write);
+
+        if (commit_every != 0 and bytes_since_commit >= commit_every) {
+            const commit_status = raw.streamCommit(stream);
+            if (commit_status != raw.Status.ok) return commit_status;
+            bytes_since_commit = 0;
+        }
+    }
+
+    if (commit_every != 0 and bytes_since_commit > 0) {
+        const commit_status = raw.streamCommit(stream);
+        if (commit_status != raw.Status.ok) return commit_status;
+    }
+
+    return raw.Status.ok;
+}