tigerbeetle-node 0.11.0 → 0.11.2

package/src/tigerbeetle/src/vsr/superblock_quorums_fuzz.zig

@@ -0,0 +1,312 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const log = std.log.scoped(.fuzz_vsr_superblock_quorums);
+
+const superblock = @import("./superblock.zig");
+const SuperBlockSector = superblock.SuperBlockSector;
+const SuperBlockVersion = superblock.SuperBlockVersion;
+
+const fuzz = @import("../test/fuzz.zig");
+const superblock_quorums = @import("superblock_quorums.zig");
+const QuorumsType = superblock_quorums.QuorumsType;
+
+pub fn main() !void {
+    const fuzz_args = try fuzz.parse_fuzz_args(std.testing.allocator);
+    var prng = std.rand.DefaultPrng.init(fuzz_args.seed);
+
+    // TODO When there is a top-level fuzz.zig main(), split these fuzzers into two different
+    // commands.
+    try fuzz_quorums_working(prng.random());
+
+    try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 4 });
+    // TODO: Enable these once SuperBlockSector is generic over its Constants.
+    // try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 6 });
+    // try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 8 });
+}
+
+pub fn fuzz_quorums_working(random: std.rand.Random) !void {
+    const r = random;
+    const t = test_quorums_working;
+    const o = CopyTemplate.make_valid;
+    const x = CopyTemplate.make_invalid_broken;
+    const X = {}; // Ignored; just for text alignment + contrast.
+
+    // No faults:
+    try t(r, 2, &.{ o(3), o(3), o(3), o(3) }, 3);
+    try t(r, 3, &.{ o(3), o(3), o(3), o(3) }, 3);
+
+    // Single fault:
+    try t(r, 3, &.{ x(X), o(4), o(4), o(4) }, 4);
+    // Double fault, same quorum:
+    try t(r, 2, &.{ x(X), x(X), o(4), o(4) }, 4);
+    try t(r, 3, &.{ x(X), x(X), o(4), o(4) }, error.QuorumLost);
+    // Double fault, different quorums:
+    try t(r, 2, &.{ x(X), x(X), o(3), o(4) }, error.QuorumLost);
+    // Triple fault.
+    try t(r, 2, &.{ x(X), x(X), x(X), o(4) }, error.QuorumLost);
+
+    // Partial format (broken sequence=1):
+    try t(r, 2, &.{ x(X), o(1), o(1), o(1) }, 1);
+    try t(r, 3, &.{ x(X), o(1), o(1), o(1) }, 1);
+    try t(r, 2, &.{ x(X), x(X), o(1), o(1) }, 1);
+    try t(r, 3, &.{ x(X), x(X), o(1), o(1) }, error.QuorumLost);
+    try t(r, 2, &.{ x(X), x(X), x(X), o(1) }, error.QuorumLost);
+    try t(r, 2, &.{ x(X), x(X), x(X), x(X) }, error.NotFound);
+
+    // Partial checkpoint() to sequence=4 (2 quorums):
+    try t(r, 2, &.{ o(3), o(2), o(2), o(2) }, 2); // open after 1/4
+    try t(r, 2, &.{ o(3), o(3), o(2), o(2) }, 3); // open after 2/4
+    try t(r, 2, &.{ o(3), o(3), o(3), o(2) }, 3); // open after 3/4
+    // Partial checkpoint() to sequence=4 (3 quorums):
+    try t(r, 2, &.{ o(1), o(2), o(3), o(3) }, 3);
+    try t(r, 3, &.{ o(1), o(2), o(3), o(3) }, error.QuorumLost);
+
+    // Skipped sequence.
+    try t(r, 2, &.{ o(2), o(2), o(2), o(4) }, error.ParentSkipped); // open after 1/4
+    try t(r, 2, &.{ o(2), o(2), o(4), o(4) }, 4); // open after 2/4
+    try t(r, 2, &.{ o(2), o(2), o(4), o(4) }, 4); // open after 3/4
+
+    // Forked sequence: same sequence number, different checksum, both valid.
+    const f = CopyTemplate.make_invalid_fork;
+    try t(r, 2, &.{ o(3), o(3), o(3), f(3) }, error.Fork);
+    try t(r, 2, &.{ o(3), o(3), f(3), f(3) }, error.Fork);
+
+    // Parent has wrong cluster|replica.
+    const m = CopyTemplate.make_invalid_misdirect;
+    try t(r, 2, &.{ m(2), m(2), m(2), o(3) }, 2);
+    try t(r, 2, &.{ m(2), m(2), o(3), o(3) }, 3);
+    try t(r, 2, &.{ m(2), o(3), o(3), o(3) }, 3);
+    // Grandparent has wrong cluster|replica.
+    try t(r, 2, &.{ m(2), m(2), m(2), o(4) }, 2);
+    try t(r, 2, &.{ m(2), m(2), o(4), o(4) }, 4);
+    try t(r, 2, &.{ m(2), o(4), o(4), o(4) }, 4);
+
+    // Parent/child hash chain is broken.
+    const p = CopyTemplate.make_invalid_parent;
+    try t(r, 2, &.{ o(2), o(2), o(2), p(3) }, 2);
+    try t(r, 2, &.{ o(2), o(2), p(3), p(3) }, error.ParentNotConnected);
+    try t(r, 2, &.{ o(2), p(3), p(3), p(3) }, error.ParentNotConnected);
+    try t(r, 2, &.{ p(3), p(3), p(3), p(3) }, 3);
+
+    // Parent view is greater than child view.
+    const v = CopyTemplate.make_invalid_vsr_state;
+    try t(r, 2, &.{ v(2), v(2), o(3), o(3) }, error.VSRStateNotMonotonic);
+
+    // A member of the quorum has an "invalid" copy, but an otherwise valid checksum.
+    const h = CopyTemplate.make_valid_high_copy;
+    try t(r, 2, &.{ o(2), o(2), o(3), h(3) }, 3);
+}
+
+fn test_quorums_working(
+    random: std.rand.Random,
+    threshold_count: u8,
+    copies: *[4]CopyTemplate,
+    result: QuorumsType(.{ .superblock_copies = 4 }).Error!u64,
+) !void {
+    const Quorums = QuorumsType(.{ .superblock_copies = 4 });
+    const misdirect = random.boolean(); // true:cluster false:replica
+    var quorums: Quorums = undefined;
+    var sectors: [4]SuperBlockSector = undefined;
+    // TODO(Zig): Ideally this would be a [6]?u128 and the access would be
+    // "checksums[i] orelse random.int(u128)", but that currently causes the compiler to segfault
+    // during code generation.
+    var checksums: [6]u128 = undefined;
+    for (checksums) |*c| c.* = random.int(u128);
+
+    // Create sectors in ascending-sequence order to build the checksum/parent hash chain.
+    std.sort.sort(CopyTemplate, copies, {}, CopyTemplate.less_than);
+
+    for (sectors) |*sector, i| {
+        sector.* = std.mem.zeroInit(SuperBlockSector, .{
+            .copy = @intCast(u8, i),
+            .version = SuperBlockVersion,
+            .replica = 1,
+            .size_max = superblock.data_file_size_min,
+            .sequence = copies[i].sequence,
+            .parent = checksums[copies[i].sequence - 1],
+        });
+
+        var checksum: ?u128 = null;
+        switch (copies[i].variant) {
+            .valid => {},
+            .valid_high_copy => sector.copy = 4,
+            .invalid_broken => {
+                if (random.boolean() and i > 0) {
+                    // Error: duplicate sector (if available).
+                    sector.* = sectors[random.uintLessThanBiased(usize, i)];
+                    checksum = random.int(u128);
+                } else {
+                    // Error: invalid checksum.
+                    checksum = random.int(u128);
+                }
+            },
+            .invalid_fork => sector.size_max += 1, // Ensure we have a different checksum.
+            .invalid_parent => sector.parent += 1,
+            .invalid_misdirect => {
+                if (misdirect) {
+                    sector.cluster += 1;
+                } else {
+                    sector.replica += 1;
+                }
+            },
+            .invalid_vsr_state => sector.vsr_state.view += 1,
+        }
+        sector.checksum = checksum orelse sector.calculate_checksum();
+
+        if (copies[i].variant == .valid or copies[i].variant == .invalid_vsr_state) {
+            checksums[sector.sequence] = sector.checksum;
+        }
+    }
+
+    for (copies) |template| {
+        if (template.variant == .valid_high_copy) break;
+    } else {
+        // Shuffling copies can only change the working quorum when we have a corrupt copy index,
+        // because we guess that the true index is the slot.
+        random.shuffle(SuperBlockSector, &sectors);
+    }
+
+    const threshold = switch (threshold_count) {
+        2 => Quorums.Threshold.open,
+        3 => Quorums.Threshold.verify,
+        else => unreachable,
+    };
+    assert(threshold.count() == threshold_count);
+
+    if (quorums.working(&sectors, threshold)) |working| {
+        try std.testing.expectEqual(result, working.sector.sequence);
+    } else |err| {
+        try std.testing.expectEqual(result, err);
+    }
+}
+
+pub const CopyTemplate = struct {
+    sequence: u64,
+    variant: Variant,
+
+    const Variant = enum {
+        valid,
+        valid_high_copy,
+        invalid_broken,
+        invalid_fork,
+        invalid_misdirect,
+        invalid_parent,
+        invalid_vsr_state,
+    };
+
+    pub fn make_valid(sequence: u64) CopyTemplate {
+        return .{ .sequence = sequence, .variant = .valid };
+    }
+
+    /// Construct a copy with a corrupt copy index (≥superblock_copies).
+    pub fn make_valid_high_copy(sequence: u64) CopyTemplate {
+        return .{ .sequence = sequence, .variant = .valid_high_copy };
+    }
+
+    /// Construct a corrupt (invalid checksum) or duplicate copy copy.
+    pub fn make_invalid_broken(_: void) CopyTemplate {
+        // Use a high sequence so that invalid copies are the last generated by
+        // test_quorums_working(), so that they can become duplicates of (earlier) valid copies.
+        return .{ .sequence = 6, .variant = .invalid_broken };
+    }
+
+    /// Construct a copy with a valid checksum — but which differs from the "canonical" version
+    /// of this sequence.
+    pub fn make_invalid_fork(sequence: u64) CopyTemplate {
+        return .{ .sequence = sequence, .variant = .invalid_fork };
+    }
+
+    /// Construct a copy with either an incorrect "cluster" or "replica".
+    pub fn make_invalid_misdirect(sequence: u64) CopyTemplate {
+        return .{ .sequence = sequence, .variant = .invalid_misdirect };
+    }
+
+    /// Construct a copy with an invalid "parent" checksum.
+    pub fn make_invalid_parent(sequence: u64) CopyTemplate {
+        return .{ .sequence = sequence, .variant = .invalid_parent };
+    }
+
+    /// Construct a copy with a newer `VSRState` than its parent.
+    pub fn make_invalid_vsr_state(sequence: u64) CopyTemplate {
+        return .{ .sequence = sequence, .variant = .invalid_vsr_state };
+    }
+
+    fn less_than(_: void, a: CopyTemplate, b: CopyTemplate) bool {
+        return a.sequence < b.sequence;
+    }
+};
+
+// Verify that a torn sector write during repair never compromises the existing quorum.
+pub fn fuzz_quorum_repairs(
+    random: std.rand.Random,
+    comptime options: superblock_quorums.Options,
+) !void {
+    const superblock_copies = options.superblock_copies;
+    const Quorums = QuorumsType(options);
+
+    var q1: Quorums = undefined;
+    var q2: Quorums = undefined;
+
+    const sectors_valid = blk: {
+        var sectors: [superblock_copies]SuperBlockSector = undefined;
+        for (&sectors) |*sector, i| {
+            sector.* = std.mem.zeroInit(SuperBlockSector, .{
+                .copy = @intCast(u8, i),
+                .version = SuperBlockVersion,
+                .replica = 1,
+                .size_max = superblock.data_file_size_min,
+                .sequence = 123,
+            });
+            sector.set_checksum();
+        }
+        break :blk sectors;
+    };
+
+    const sector_invalid = blk: {
+        var sector = sectors_valid[0];
+        sector.checksum = 456;
+        break :blk sector;
+    };
+
+    // Generate a random valid 2/4 quorum.
+    // 1 bits indicate valid sectors.
+    // 0 bits indicate invalid sectors.
+    var valid = std.bit_set.IntegerBitSet(superblock_copies).initEmpty();
+    while (valid.count() < Quorums.Threshold.open.count() or random.boolean()) {
+        valid.set(random.uintLessThan(usize, superblock_copies));
+    }
+
+    var working_sectors: [superblock_copies]SuperBlockSector = undefined;
+    for (&working_sectors) |*sector, i| {
+        sector.* = if (valid.isSet(i)) sectors_valid[i] else sector_invalid;
+    }
+    random.shuffle(SuperBlockSector, &working_sectors);
+    var repair_sectors = working_sectors;
+
+    const working_quorum = q1.working(&working_sectors, .open) catch unreachable;
+    var quorum_repairs = working_quorum.repairs();
+    while (quorum_repairs.next()) |repair_copy| {
+        {
+            // Simulate a torn sector write, crash, recover sequence.
+            var damaged_sectors = repair_sectors;
+            damaged_sectors[repair_copy] = sector_invalid;
+            const damaged_quorum = q2.working(&damaged_sectors, .open) catch unreachable;
+            assert(damaged_quorum.sector.checksum == working_quorum.sector.checksum);
+        }
+
+        // "Finish" the write so that we can test the next repair.
+        repair_sectors[repair_copy] = sectors_valid[repair_copy];
+
+        const quorum_repaired = q2.working(&repair_sectors, .open) catch unreachable;
+        assert(quorum_repaired.sector.checksum == working_quorum.sector.checksum);
+    }
+
+    // At the end of all repairs, we expect to have every copy of the superblock.
+    // They do not need to be in their home slot.
+    var copies = Quorums.QuorumCount.initEmpty();
+    for (repair_sectors) |repair_sector| {
+        assert(repair_sector.checksum == working_quorum.sector.checksum);
+        copies.set(repair_sector.copy);
+    }
+    assert(repair_sectors.len == copies.count());
+}

package/src/tigerbeetle/src/vsr.zig

@@ -24,11 +24,23 @@ pub const ProcessType = enum { replica, client };
 
 pub const Zone = enum {
     superblock,
-    wal,
+    wal_headers,
+    wal_prepares,
     grid,
 
     const size_superblock = @import("vsr/superblock.zig").superblock_zone_size;
-    const size_wal = config.journal_size_max;
+    const size_wal_headers = config.journal_size_headers;
+    const size_wal_prepares = config.journal_size_prepares;
+
+    comptime {
+        for (.{
+            size_superblock,
+            size_wal_headers,
+            size_wal_prepares,
+        }) |zone_size| {
+            assert(zone_size % config.sector_size == 0);
+        }
+    }
 
     pub fn offset(zone: Zone, offset_logical: u64) u64 {
         if (zone.size()) |zone_size| {
@@ -37,15 +49,17 @@ pub const Zone = enum {
 
         return offset_logical + switch (zone) {
             .superblock => 0,
-            .wal => size_superblock,
-            .grid => size_superblock + size_wal,
+            .wal_headers => size_superblock,
+            .wal_prepares => size_superblock + size_wal_headers,
+            .grid => size_superblock + size_wal_headers + size_wal_prepares,
         };
     }
 
     pub fn size(zone: Zone) ?u64 {
         return switch (zone) {
             .superblock => size_superblock,
-            .wal => size_wal,
+            .wal_headers => size_wal_headers,
+            .wal_prepares => size_wal_prepares,
             .grid => null,
         };
     }

package/src/tigerbeetle/src/benchmark_array_search.zig

@@ -1,317 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const math = std.math;
-
-const binary_search = @import("./binary_search.zig").binary_search;
-const eytzinger = @import("./eytzinger.zig").eytzinger;
-const perf = @import("./benchmarks/perf.zig");
-
-const GiB = 1 << 30;
-const searches = 500_000;
-
-const kv_types = .{
-    .{ .key_size = 8, .value_size = 128 },
-    .{ .key_size = 8, .value_size = 64 },
-    .{ .key_size = 16, .value_size = 16 },
-    .{ .key_size = 32, .value_size = 32 },
-};
-
-// keys_per_summary = values_per_page / summary_fraction
-const summary_fractions = .{ 4, 8, 16, 32 };
-const values_per_page = .{ 128, 256, 512, 1024, 2048, 4096, 8192 };
-const body_fmt = "{:_>2}B/{:_>3}B {:_>4}/{:_>4} {s}{s}: WT={:_>6}ns UT={:_>6}ns" ++
-    " CY={:_>6} IN={:_>6} CR={:_>5} CM={:_>5} BM={}\n";
-
-const summary_sizes = blk: {
-    var sizes: [values_per_page.len][summary_fractions.len]usize = undefined;
-    for (values_per_page) |values_count, v| {
-        for (summary_fractions) |fraction, k| {
-            // Set in reverse order so that the summary sizes ascend.
-            sizes[v][summary_fractions.len - k - 1] = values_count / fraction;
-        }
-    }
-    break :blk sizes;
-};
-
-pub fn main() !void {
-    std.log.info("Samples: {}", .{searches});
-    std.log.info("WT: Wall time/search", .{});
-    std.log.info("UT: utime time/search", .{});
-    std.log.info("CY: CPU cycles/search", .{});
-    std.log.info("IN: instructions/search", .{});
-    std.log.info("CR: cache references/search", .{});
-    std.log.info("CM: cache misses/search", .{});
-    std.log.info("BM: branch misses/search", .{});
-
-    var seed: u64 = undefined;
-    try std.os.getrandom(std.mem.asBytes(&seed));
-    var prng = std.rand.DefaultPrng.init(seed);
-
-    // Allocate on the heap just once.
-    // All page allocations reuse this buffer to speed up the run time.
-    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena.deinit();
-
-    const blob_size = GiB;
-    var blob = try arena.allocator.alloc(u8, blob_size);
-
-    inline for (kv_types) |kv| {
-        inline for (values_per_page) |values_count, v| {
-            inline for (summary_sizes[v]) |keys_count| {
-                try run_benchmark(.{
-                    .blob_size = blob_size,
-                    .key_size = kv.key_size,
-                    .value_size = kv.value_size,
-                    .keys_count = keys_count,
-                    .values_count = values_count,
-                    .searches = searches,
-                }, blob, &prng.random);
-            }
-        }
-    }
-}
-
-fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random) !void {
-    assert(blob.len == layout.blob_size);
-    const Eytzinger = eytzinger(layout.keys_count - 1, layout.values_count);
-    const V = Value(layout);
-    const K = V.Key;
-    const Page = struct {
-        keys: [layout.keys_count]K,
-        values: [layout.values_count]V,
-    };
-    const page_count = layout.blob_size / @sizeOf(Page);
-
-    // Search pages and keys in random order.
-    var page_picker = shuffled_index(page_count, random);
-    var value_picker = shuffled_index(layout.values_count, random);
-
-    // Generate 1GiB worth of 24KiB pages.
-    var blob_alloc = std.heap.FixedBufferAllocator.init(blob);
-    var pages = try blob_alloc.allocator.alloc(Page, page_count);
-    random.bytes(std.mem.sliceAsBytes(pages));
-    for (pages) |*page| {
-        for (page.values) |*value, i| value.key = i;
-        Eytzinger.layout_from_keys_or_values(K, V, V.key_from_value, V.max_key, &page.values, &page.keys);
-    }
-
-    const stdout = std.io.getStdOut().writer();
-    {
-        var benchmark = try Benchmark.begin();
-        var i: usize = 0;
-        var v: usize = 0;
-        while (i < layout.searches) : (i += 1) {
-            const page_index = page_picker[i % page_picker.len];
-            const target = value_picker[v % value_picker.len];
-            const page = &pages[page_index];
-            const bounds = Eytzinger.search_values(K, V, V.key_compare, &page.keys, &page.values, target);
-            const hit = bounds[binary_search(K, V, V.key_from_value, V.key_compare, bounds, target, .{})];
-
-            assert(hit.key == target);
-            if (i % pages.len == 0) v += 1;
-        }
-
-        const result = try benchmark.end(layout.searches);
-        try stdout.print(body_fmt, .{
-            layout.key_size,
-            layout.value_size,
-            layout.keys_count,
-            layout.values_count,
-            "E",
-            "B",
-            result.wall_time,
-            result.utime,
-            result.cpu_cycles,
-            result.instructions,
-            result.cache_references,
-            result.cache_misses,
-            result.branch_misses,
-        });
-    }
-
-    {
-        var benchmark = try Benchmark.begin();
-        var i: usize = 0;
-        var v: usize = 0;
-        while (i < layout.searches) : (i += 1) {
-            const target = value_picker[v % value_picker.len];
-            const page = &pages[page_picker[i % page_picker.len]];
-            const hit = page.values[binary_search(K, V, V.key_from_value, V.key_compare, page.values[0..], target, .{})];
-
-            assert(hit.key == target);
-            if (i % pages.len == 0) v += 1;
-        }
-        const result = try benchmark.end(layout.searches);
-        try stdout.print(body_fmt, .{
-            layout.key_size,
-            layout.value_size,
-            layout.keys_count,
-            layout.values_count,
-            "_",
-            "B",
-            result.wall_time,
-            result.utime,
-            result.cpu_cycles,
-            result.instructions,
-            result.cache_references,
-            result.cache_misses,
-            result.branch_misses,
-        });
-    }
-}
-
-const Layout = struct {
-    blob_size: usize, // bytes allocated for all pages
-    key_size: usize, // bytes per key
-    value_size: usize, // bytes per value
-    keys_count: usize, // keys per page (in the summary)
-    values_count: usize, // values per page
-    searches: usize,
-};
-
-fn Value(comptime layout: Layout) type {
-    return struct {
-        pub const max_key = 1 << (8 * layout.key_size) - 1;
-        pub const Key = math.IntFittingRange(0, max_key);
-        const Self = @This();
-        key: Key,
-        body: [layout.value_size - layout.key_size]u8,
-
-        comptime {
-            assert(@sizeOf(Key) == layout.key_size);
-            assert(@sizeOf(Self) == layout.value_size);
-        }
-
-        inline fn key_from_value(self: Self) Key {
-            return self.key;
-        }
-
-        inline fn key_from_key(x: Key) Key {
-            return x;
-        }
-
-        inline fn key_compare(a: Key, b: Key) math.Order {
-            return math.order(a, b);
-        }
-    };
-}
-
-const BenchmarkResult = struct {
-    wall_time: u64, // nanoseconds
-    utime: u64, // nanoseconds
-    cpu_cycles: usize,
-    instructions: usize,
-    cache_references: usize,
-    cache_misses: usize,
-    branch_misses: usize,
-};
-
-const PERF = perf.PERF;
-const perf_event_attr = perf.perf_event_attr;
-const perf_event_open = perf.perf_event_open;
-const perf_counters = [_]PERF.COUNT.HW{
-    PERF.COUNT.HW.CPU_CYCLES,
-    PERF.COUNT.HW.INSTRUCTIONS,
-    PERF.COUNT.HW.CACHE_REFERENCES,
-    PERF.COUNT.HW.CACHE_MISSES,
-    PERF.COUNT.HW.BRANCH_MISSES,
-};
-
-const Benchmark = struct {
-    timer: std.time.Timer,
-    rusage: std.os.rusage,
-    perf_fds: [perf_counters.len]std.os.fd_t,
-
-    fn begin() !Benchmark {
-        const flags = PERF.FLAG.FD_NO_GROUP;
-        var perf_fds = [1]std.os.fd_t{-1} ** perf_counters.len;
-        for (perf_counters) |counter, i| {
-            var attr: perf_event_attr = .{
-                .type = PERF.TYPE.HARDWARE,
-                .config = @enumToInt(counter),
-                .flags = .{
-                    .disabled = true,
-                    .exclude_kernel = true,
-                    .exclude_hv = true,
-                },
-            };
-            perf_fds[i] = try perf_event_open(&attr, 0, -1, perf_fds[0], PERF.FLAG.FD_CLOEXEC);
-        }
-        const err = std.os.linux.ioctl(perf_fds[0], PERF.EVENT_IOC.ENABLE, PERF.IOC_FLAG_GROUP);
-        if (err == -1) return error.Unexpected;
-
-        // Start the wall clock after perf, since setup is slow.
-        const timer = try std.time.Timer.start();
-        return Benchmark{
-            .timer = timer,
-            // TODO pass std.os.linux.rusage.SELF once Zig is upgraded
-            .rusage = std.os.getrusage(0),
-            .perf_fds = perf_fds,
-        };
-    }
-
-    fn end(self: *Benchmark, samples: usize) !BenchmarkResult {
-        defer {
-            for (perf_counters) |_, i| {
-                std.os.close(self.perf_fds[i]);
-                self.perf_fds[i] = -1;
-            }
-        }
-
-        const rusage = std.os.getrusage(0);
-        const err = std.os.linux.ioctl(self.perf_fds[0], PERF.EVENT_IOC.DISABLE, PERF.IOC_FLAG_GROUP);
-        if (err == -1) return error.Unexpected;
-        return BenchmarkResult{
-            .wall_time = self.timer.read() / samples,
-            .utime = (timeval_to_ns(rusage.utime) - timeval_to_ns(self.rusage.utime)) / samples,
-            .cpu_cycles = (try readPerfFd(self.perf_fds[0])) / samples,
-            .instructions = (try readPerfFd(self.perf_fds[1])) / samples,
-            .cache_references = (try readPerfFd(self.perf_fds[2])) / samples,
-            .cache_misses = (try readPerfFd(self.perf_fds[3])) / samples,
-            .branch_misses = (try readPerfFd(self.perf_fds[4])) / samples,
-        };
-    }
-};
-
-// shuffle([0,1,…,n-1])
-fn shuffled_index(comptime n: usize, rand: *std.rand.Random) [n]usize {
-    var indices: [n]usize = undefined;
-    for (indices) |*i, j| i.* = j;
-    rand.shuffle(usize, indices[0..]);
-    return indices;
-}
-
-fn timeval_to_ns(tv: std.os.timeval) u64 {
-    const ns_per_us = std.time.ns_per_s / std.time.us_per_s;
-    return @bitCast(u64, tv.tv_sec) * std.time.ns_per_s +
-        @bitCast(u64, tv.tv_usec) * ns_per_us;
-}
-
-fn readPerfFd(fd: std.os.fd_t) !usize {
-    var result: usize = 0;
-    const n = try std.os.read(fd, std.mem.asBytes(&result));
-    assert(n == @sizeOf(usize));
-
-    return result;
-}
-
-fn binary_search_keys(
-    comptime layout: Layout,
-    comptime Key: type,
-    comptime V: type,
-    comptime compare_keys: fn (Key, Key) math.Order,
-    keys: []const Key,
-    values: []const V,
-    key: Key,
-) []const V {
-    assert(keys.len == layout.keys_count);
-    assert(values.len == layout.values_count);
-
-    const key_index = binary_search(Key, Key, V.key_from_key, compare_keys, keys, key, .{});
-    const key_stride = layout.values_count / layout.keys_count;
-    const high = key_index * key_stride;
-    if (key_index < keys.len and keys[key_index] == key) {
-        return if (high == 0) values[0..1] else values[high - 1 .. high];
-    }
-    return values[high - key_stride .. high];
-}