tigerbeetle-node 0.11.8 → 0.11.10

package/src/tigerbeetle/src/lsm/forest_fuzz.zig

@@ -4,7 +4,7 @@ const allocator = testing.allocator;
 const assert = std.debug.assert;
 
 const constants = @import("../constants.zig");
-const fuzz = @import("../test/fuzz.zig");
+const fuzz = @import("../testing/fuzz.zig");
 const vsr = @import("../vsr.zig");
 
 const log = std.log.scoped(.lsm_forest_fuzz);
@@ -13,7 +13,7 @@ const tracer = @import("../tracer.zig");
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Transfer = @import("../tigerbeetle.zig").Transfer;
 const Account = @import("../tigerbeetle.zig").Account;
-const Storage = @import("../test/storage.zig").Storage;
+const Storage = @import("../testing/storage.zig").Storage;
 const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
     .message_body_size_max = constants.message_body_size_max,
 });
@@ -62,77 +62,48 @@ const Environment = struct {
     ) catch unreachable;
 
     const State = enum {
-        uninit,
         init,
-        formatted,
+        superblock_format,
         superblock_open,
+        forest_init,
         forest_open,
-        forest_compacting,
-        forest_checkpointing,
-        superblock_checkpointing,
+        fuzzing,
+        forest_compact,
+        forest_checkpoint,
+        superblock_checkpoint,
     };
 
     state: State,
     storage: *Storage,
     message_pool: MessagePool,
     superblock: SuperBlock,
-    superblock_context: SuperBlock.Context = undefined,
+    superblock_context: SuperBlock.Context,
     grid: Grid,
     forest: Forest,
-    // We need @fieldParentPtr() of forest, so we can't use an optional Forest.
-    forest_exists: bool,
-    checkpoint_op: ?u64 = null,
-
-    fn init(env: *Environment, storage: *Storage) !void {
-        env.state = .uninit;
+    checkpoint_op: ?u64,
 
+    pub fn run(storage: *Storage, fuzz_ops: []const FuzzOp) !void {
+        var env: Environment = undefined;
+        env.state = .init;
         env.storage = storage;
-        errdefer env.storage.deinit(allocator);
 
         env.message_pool = try MessagePool.init(allocator, .replica);
-        errdefer env.message_pool.deinit(allocator);
+        defer env.message_pool.deinit(allocator);
 
         env.superblock = try SuperBlock.init(allocator, .{
             .storage = env.storage,
             .storage_size_limit = constants.storage_size_max,
             .message_pool = &env.message_pool,
         });
-        errdefer env.superblock.deinit(allocator);
+        defer env.superblock.deinit(allocator);
 
         env.grid = try Grid.init(allocator, &env.superblock);
-        errdefer env.grid.deinit(allocator);
+        defer env.grid.deinit(allocator);
 
-        // Forest must be initialized with an open superblock.
         env.forest = undefined;
-        env.forest_exists = false;
-
-        env.state = .init;
-    }
-
-    fn deinit(env: *Environment) void {
-        assert(env.state != .uninit);
-
-        if (env.forest_exists) {
-            env.forest.deinit(allocator);
-            env.forest_exists = false;
-        }
-        env.grid.deinit(allocator);
-        env.superblock.deinit(allocator);
-        env.message_pool.deinit(allocator);
-
-        env.state = .uninit;
-    }
-
-    fn tick(env: *Environment) void {
-        // env.grid.tick();
-        env.storage.tick();
-    }
+        env.checkpoint_op = null;
 
-    fn tick_until_state_change(env: *Environment, current_state: State, next_state: State) void {
-        // Sometimes IO completes synchronously (eg if cached), so we might already be in next_state before ticking.
-        assert(env.state == current_state or env.state == next_state);
-        while (env.state == current_state) env.tick();
-        assert(env.state == next_state);
+        try env.open_then_apply(fuzz_ops);
     }
 
     fn change_state(env: *Environment, current_state: State, next_state: State) void {
@@ -140,79 +111,86 @@ const Environment = struct {
         env.state = next_state;
     }
 
-    pub fn format(storage: *Storage) !void {
-        var env: Environment = undefined;
-
-        try env.init(storage);
-        defer env.deinit();
+    fn tick_until_state_change(env: *Environment, current_state: State, next_state: State) void {
+        // Sometimes operations complete synchronously so we might already be in next_state before ticking.
+        //assert(env.state == current_state or env.state == next_state);
+        while (env.state == current_state) env.storage.tick();
+        assert(env.state == next_state);
+    }
 
-        assert(env.state == .init);
+    pub fn open_then_apply(env: *Environment, fuzz_ops: []const FuzzOp) !void {
+        env.change_state(.init, .superblock_format);
         env.superblock.format(superblock_format_callback, &env.superblock_context, .{
             .cluster = cluster,
             .replica = replica,
         });
-        env.tick_until_state_change(.init, .formatted);
+
+        env.tick_until_state_change(.superblock_format, .superblock_open);
+        env.superblock.open(superblock_open_callback, &env.superblock_context);
+
+        env.tick_until_state_change(.superblock_open, .forest_init);
+        env.forest = try Forest.init(allocator, &env.grid, node_count, forest_options);
+        defer env.forest.deinit(allocator);
+
+        env.change_state(.forest_init, .forest_open);
+        env.forest.open(forest_open_callback);
+
+        env.tick_until_state_change(.forest_open, .fuzzing);
+        try env.apply(fuzz_ops);
     }
 
     fn superblock_format_callback(superblock_context: *SuperBlock.Context) void {
         const env = @fieldParentPtr(@This(), "superblock_context", superblock_context);
-        env.change_state(.init, .formatted);
-    }
-
-    pub fn open(env: *Environment) void {
-        assert(env.state == .init);
-        env.superblock.open(superblock_open_callback, &env.superblock_context);
-        env.tick_until_state_change(.init, .forest_open);
+        env.change_state(.superblock_format, .superblock_open);
     }
 
     fn superblock_open_callback(superblock_context: *SuperBlock.Context) void {
         const env = @fieldParentPtr(@This(), "superblock_context", superblock_context);
-        env.change_state(.init, .superblock_open);
-        env.forest = Forest.init(allocator, &env.grid, node_count, forest_options) catch unreachable;
-        env.forest_exists = true;
-        env.forest.open(forest_open_callback);
+        env.change_state(.superblock_open, .forest_init);
     }
 
     fn forest_open_callback(forest: *Forest) void {
         const env = @fieldParentPtr(@This(), "forest", forest);
-        env.change_state(.superblock_open, .forest_open);
+        env.change_state(.forest_open, .fuzzing);
     }
 
     pub fn compact(env: *Environment, op: u64) void {
-        env.change_state(.forest_open, .forest_compacting);
+        env.change_state(.fuzzing, .forest_compact);
         env.forest.compact(forest_compact_callback, op);
-        env.tick_until_state_change(.forest_compacting, .forest_open);
+        env.tick_until_state_change(.forest_compact, .fuzzing);
     }
 
     fn forest_compact_callback(forest: *Forest) void {
         const env = @fieldParentPtr(@This(), "forest", forest);
-        env.change_state(.forest_compacting, .forest_open);
+        env.change_state(.forest_compact, .fuzzing);
     }
 
     pub fn checkpoint(env: *Environment, op: u64) void {
+        assert(env.checkpoint_op == null);
         env.checkpoint_op = op - constants.lsm_batch_multiple;
-        env.change_state(.forest_open, .forest_checkpointing);
+
+        env.change_state(.fuzzing, .forest_checkpoint);
         env.forest.checkpoint(forest_checkpoint_callback);
-        env.tick_until_state_change(.forest_checkpointing, .superblock_checkpointing);
-        env.tick_until_state_change(.superblock_checkpointing, .forest_open);
+        env.tick_until_state_change(.forest_checkpoint, .superblock_checkpoint);
+        env.tick_until_state_change(.superblock_checkpoint, .fuzzing);
     }
 
     fn forest_checkpoint_callback(forest: *Forest) void {
         const env = @fieldParentPtr(@This(), "forest", forest);
-        env.change_state(.forest_checkpointing, .superblock_checkpointing);
+        const op = env.checkpoint_op.?;
+        env.checkpoint_op = null;
+
+        env.change_state(.forest_checkpoint, .superblock_checkpoint);
         env.superblock.checkpoint(superblock_checkpoint_callback, &env.superblock_context, .{
             .commit_min_checksum = env.superblock.working.vsr_state.commit_min_checksum + 1,
-            .commit_min = env.checkpoint_op.?,
-            .commit_max = env.checkpoint_op.? + 1,
-            .view_normal = 0,
-            .view = 0,
+            .commit_min = op,
+            .commit_max = op + 1,
         });
-        env.checkpoint_op = null;
     }
 
     fn superblock_checkpoint_callback(superblock_context: *SuperBlock.Context) void {
         const env = @fieldParentPtr(@This(), "superblock_context", superblock_context);
-        env.change_state(.superblock_checkpointing, .forest_open);
+        env.change_state(.superblock_checkpoint, .fuzzing);
     }
 
     fn prefetch_account(env: *Environment, id: u128) void {
@@ -230,31 +208,27 @@ const Environment = struct {
         groove.prefetch_setup(null);
         groove.prefetch_enqueue(id);
         groove.prefetch(Getter.prefetch_callback, &getter.prefetch_context);
-        while (!getter.finished) env.tick();
+        while (!getter.finished) env.storage.tick();
     }
 
-    fn run(storage: *Storage, fuzz_ops: []const FuzzOp) !void {
-        var env: Environment = undefined;
-
-        try env.init(storage);
-        defer env.deinit();
-
-        // Open the superblock then forest.
-        env.open();
-
+    fn apply(env: *Environment, fuzz_ops: []const FuzzOp) !void {
         // The forest should behave like a simple key-value data-structure.
         // We'll compare it to a hash map.
         var model = std.hash_map.AutoHashMap(u128, Account).init(allocator);
         defer model.deinit();
 
         for (fuzz_ops) |fuzz_op, fuzz_op_index| {
+            assert(env.state == .fuzzing);
             log.debug("Running fuzz_ops[{}/{}] == {}", .{ fuzz_op_index, fuzz_ops.len, fuzz_op });
-            const storage_size_used = storage.size_used();
-            log.debug("storage.size_used = {}/{}", .{ storage_size_used, storage.size });
+
+            const storage_size_used = env.storage.size_used();
+            log.debug("storage.size_used = {}/{}", .{ storage_size_used, env.storage.size });
+
             const model_size = model.count() * @sizeOf(Account);
             log.debug("space_amplification = {d:.2}", .{
                 @intToFloat(f64, storage_size_used) / @intToFloat(f64, model_size),
             });
+
             // Apply fuzz_op to the forest and the model.
             switch (fuzz_op) {
                 .compact => |compact| {
@@ -294,7 +268,6 @@ pub fn run_fuzz_ops(storage_options: Storage.Options, fuzz_ops: []const FuzzOp)
     var storage = try Storage.init(allocator, constants.storage_size_max, storage_options);
     defer storage.deinit(allocator);
 
-    try Environment.format(&storage);
     try Environment.run(&storage, fuzz_ops);
 }
 
@@ -328,8 +301,8 @@ pub fn generate_fuzz_ops(random: std.rand.Random, fuzz_op_count: usize) ![]const
     log.info("puts_since_compact_max = {}", .{Environment.puts_since_compact_max});
     log.info("compacts_per_checkpoint = {}", .{Environment.compacts_per_checkpoint});
 
-    var id_to_timestamp = std.hash_map.AutoHashMap(u128, u64).init(allocator);
-    defer id_to_timestamp.deinit();
+    var id_to_account = std.hash_map.AutoHashMap(u128, Account).init(allocator);
+    defer id_to_account.deinit();
 
     var op: u64 = 1;
     var puts_since_compact: usize = 0;
@@ -359,12 +332,10 @@ pub fn generate_fuzz_ops(random: std.rand.Random, fuzz_op_count: usize) ![]const
             },
             .put_account => put_account: {
                 const id = random_id(random, u128);
-                // `timestamp` just needs to be unique, but we're not allowed to change the timestamp of an existing account.
-                const timestamp = id_to_timestamp.get(id) orelse fuzz_op_index;
-                try id_to_timestamp.put(id, timestamp);
-                break :put_account FuzzOp{ .put_account = Account{
+                var account = id_to_account.get(id) orelse Account{
                     .id = id,
-                    .timestamp = timestamp,
+                    // `timestamp` must be unique.
+                    .timestamp = fuzz_op_index,
                     .user_data = random_id(random, u128),
                     .reserved = [_]u8{0} ** 48,
                     .ledger = random_id(random, u32),
@@ -373,11 +344,20 @@ pub fn generate_fuzz_ops(random: std.rand.Random, fuzz_op_count: usize) ![]const
                         .debits_must_not_exceed_credits = random.boolean(),
                         .credits_must_not_exceed_debits = random.boolean(),
                     },
-                    .debits_pending = random.int(u64),
-                    .debits_posted = random.int(u64),
-                    .credits_pending = random.int(u64),
-                    .credits_posted = random.int(u64),
-                } };
+                    .debits_pending = 0,
+                    .debits_posted = 0,
+                    .credits_pending = 0,
+                    .credits_posted = 0,
+                };
+
+                // These are the only fields we are allowed to change on existing accounts.
+                account.debits_pending = random.int(u64);
+                account.debits_posted = random.int(u64);
+                account.credits_pending = random.int(u64);
+                account.credits_posted = random.int(u64);
+
+                try id_to_account.put(account.id, account);
+                break :put_account FuzzOp{ .put_account = account };
             },
             .get_account => FuzzOp{
                 .get_account = random_id(random, u128),

package/src/tigerbeetle/src/lsm/grid.zig

@@ -10,7 +10,7 @@ const SuperBlockType = vsr.SuperBlockType;
 const FIFO = @import("../fifo.zig").FIFO;
 const IOPS = @import("../iops.zig").IOPS;
 const SetAssociativeCache = @import("set_associative_cache.zig").SetAssociativeCache;
-const util = @import("../util.zig");
+const stdx = @import("../stdx.zig");
 
 const log = std.log.scoped(.grid);
 
@@ -36,6 +36,15 @@ pub const BlockType = enum(u8) {
     }
 };
 
+// Leave this outside GridType so we can call it from modules that don't know about Storage.
+pub fn alloc_block(
+    allocator: mem.Allocator,
+) !*align(constants.sector_size) [constants.block_size]u8 {
+    const block = try allocator.alignedAlloc(u8, constants.sector_size, constants.block_size);
+    mem.set(u8, block, 0);
+    return block[0..constants.block_size];
+}
+
 /// The Grid provides access to on-disk blocks (blobs of `block_size` bytes).
 /// Each block is identified by an "address" (`u64`, beginning at 1).
 ///
@@ -180,11 +189,6 @@ pub fn GridType(comptime Storage: type) type {
             };
         }
 
-        pub fn alloc_block(allocator: mem.Allocator) !BlockPtr {
-            const block = try allocator.alignedAlloc(u8, constants.sector_size, block_size);
-            return block[0..block_size];
-        }
-
         pub fn deinit(grid: *Grid, allocator: mem.Allocator) void {
             for (&grid.read_iop_blocks) |block| allocator.free(block);
 
@@ -292,6 +296,12 @@ pub fn GridType(comptime Storage: type) type {
             grid.assert_not_writing(address, block.*);
             grid.assert_not_reading(address, block.*);
 
+            if (constants.verify) {
+                for (grid.cache_blocks) |cache_block| {
+                    assert(cache_block != block.*);
+                }
+            }
+
             assert(grid.superblock.opened);
             assert(!grid.superblock.free_set.is_free(address));
 
@@ -340,9 +350,7 @@ pub fn GridType(comptime Storage: type) type {
             const cache_index = grid.cache.insert_index(&completed_write.address);
             const cache_block = &grid.cache_blocks[cache_index];
             std.mem.swap(BlockPtr, cache_block, completed_write.block);
-            if (constants.verify) {
-                std.mem.set(u8, completed_write.block.*, undefined);
-            }
+            std.mem.set(u8, completed_write.block.*, 0);
 
             // Start a queued write if possible *before* calling the completed
             // write's callback. This ensures that if the callback calls
@@ -462,9 +470,7 @@ pub fn GridType(comptime Storage: type) type {
             const cache_index = grid.cache.insert_index(&read.address);
             const cache_block = &grid.cache_blocks[cache_index];
             std.mem.swap(BlockPtr, iop_block, cache_block);
-            if (constants.verify) {
-                std.mem.set(u8, iop_block.*, undefined);
-            }
+            std.mem.set(u8, iop_block.*, 0);
 
             // Handoff the iop to a pending read or release it before resolving the callbacks below.
             if (grid.read_pending_queue.pop()) |pending| {
@@ -556,7 +562,7 @@ pub fn GridType(comptime Storage: type) type {
         }
 
         fn verify_cached_read(grid: *Grid, address: u64, cached_block: BlockPtrConst) void {
-            if (Storage != @import("../test/storage.zig").Storage)
+            if (Storage != @import("../testing/storage.zig").Storage)
                 // Too complicated to do async verification
                 return;
 

package/src/tigerbeetle/src/lsm/manifest_log.zig

@@ -28,11 +28,12 @@ const log = std.log.scoped(.manifest_log);
 
 const constants = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
-const util = @import("../util.zig");
+const stdx = @import("../stdx.zig");
 
 const SuperBlockType = vsr.SuperBlockType;
 const GridType = @import("grid.zig").GridType;
 const BlockType = @import("grid.zig").BlockType;
+const alloc_block = @import("grid.zig").alloc_block;
 const tree = @import("tree.zig");
 const RingBuffer = @import("../ring_buffer.zig").RingBuffer;
 
@@ -93,7 +94,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             tree.compaction_tables_input_max + // Remove.
             tree.compaction_tables_output_max);
 
-        const blocks_count_appends = util.div_ceil(compaction_appends_max, Block.entry_count_max);
+        const blocks_count_appends = stdx.div_ceil(compaction_appends_max, Block.entry_count_max);
 
         /// The upper-bound of manifest log blocks we must buffer.
         ///
@@ -151,10 +152,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             var blocks: [blocks_count_max]BlockPtr = undefined;
             for (blocks) |*block, i| {
                 errdefer for (blocks[0..i]) |b| allocator.free(b);
-
-                const block_slice =
-                    try allocator.alignedAlloc(u8, constants.sector_size, constants.block_size);
-                block.* = block_slice[0..constants.block_size];
+                block.* = try alloc_block(allocator);
             }
             errdefer for (blocks) |b| allocator.free(b);
 
@@ -255,7 +253,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
                 const label = labels_used[entry];
                 const table = &tables_used[entry];
 
-                if (manifest.insert_table_extent(table.address, block_reference.address, entry)) {
+                if (manifest.insert_table_extent(manifest_log.tree_hash, table.address, block_reference.address, entry)) {
                     switch (label.event) {
                         .insert => manifest_log.open_event(manifest_log, label.level, table),
                         .remove => manifest.queue_for_compaction(block_reference.address),
@@ -332,7 +330,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
 
             const manifest: *SuperBlock.Manifest = &manifest_log.superblock.manifest;
             const address = Block.address(block);
-            if (manifest.update_table_extent(table.address, address, entry)) |previous_block| {
+            if (manifest.update_table_extent(manifest_log.tree_hash, table.address, address, entry)) |previous_block| {
                 manifest.queue_for_compaction(previous_block);
                 if (label.event == .remove) manifest.queue_for_compaction(address);
             } else {
@@ -433,6 +431,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
                 block,
                 address,
             );
+            manifest_log.blocks.advance_head();
         }
 
         fn write_block_callback(write: *Grid.Write) void {
@@ -441,7 +440,6 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
             assert(manifest_log.writing);
 
             manifest_log.blocks_closed -= 1;
-            manifest_log.blocks.advance_head();
             assert(manifest_log.blocks_closed <= manifest_log.blocks.count);
 
             manifest_log.write_block();
@@ -547,7 +545,7 @@ pub fn ManifestLogType(comptime Storage: type, comptime TableInfo: type) type {
                 // Remove the extent if the table is the latest version.
                 // We must iterate entries in forward order to drop the extent here.
                 // Otherwise, stale versions earlier in the block may reappear.
-                if (manifest.remove_table_extent(table.address, block_reference.address, entry)) {
+                if (manifest.remove_table_extent(manifest_log.tree_hash, table.address, block_reference.address, entry)) {
                     switch (label.event) {
                         // Append the table, updating the table extent:
                         .insert => manifest_log.append(label, table),

package/src/tigerbeetle/src/lsm/manifest_log_fuzz.zig

@@ -22,11 +22,11 @@ const MessagePool = @import("../message_pool.zig").MessagePool;
 const SuperBlock = @import("../vsr/superblock.zig").SuperBlockType(Storage);
 const data_file_size_min = @import("../vsr/superblock.zig").data_file_size_min;
 const TableExtent = @import("../vsr/superblock_manifest.zig").Manifest.TableExtent;
-const Storage = @import("../test/storage.zig").Storage;
+const Storage = @import("../testing/storage.zig").Storage;
 const Grid = @import("grid.zig").GridType(Storage);
 const BlockType = @import("grid.zig").BlockType;
 const ManifestLog = @import("manifest_log.zig").ManifestLogType(Storage, TableInfo);
-const fuzz = @import("../test/fuzz.zig");
+const fuzz = @import("../testing/fuzz.zig");
 
 pub const tigerbeetle_config = @import("../config.zig").configs.test_min;
 
@@ -198,7 +198,7 @@ fn generate_events(
         event.* = switch (event_type) {
             .insert_new => insert: {
                 const level = random.uintLessThan(u7, constants.lsm_levels);
-                const table = .{
+                const table = TableInfo{
                     .checksum = 0,
                     .address = i + 1,
                     .snapshot_min = 1,
@@ -210,10 +210,11 @@ fn generate_events(
                     .level = level,
                     .table = table,
                 });
-                break :insert ManifestEvent{ .insert = .{
+                const insert = ManifestEvent{ .insert = .{
                     .level = level,
                     .table = table,
                 } };
+                break :insert insert;
             },
 
             .insert_change_level => insert: {
@@ -223,27 +224,30 @@ fn generate_events(
                 }
 
                 table.level += 1;
-                break :insert ManifestEvent{ .insert = .{
+                const insert = ManifestEvent{ .insert = .{
                     .level = table.level,
                     .table = table.table,
                 } };
+                break :insert insert;
             },
 
             .insert_change_snapshot => insert: {
                 const table = &tables.items[random.uintLessThan(usize, tables.items.len)];
                 table.table.snapshot_max += 1;
-                break :insert ManifestEvent{ .insert = .{
+                const insert = ManifestEvent{ .insert = .{
                     .level = table.level,
                     .table = table.table,
                 } };
+                break :insert insert;
             },
 
             .remove => remove: {
                 const table = tables.swapRemove(random.uintLessThan(usize, tables.items.len));
-                break :remove ManifestEvent{ .remove = .{
+                const remove = ManifestEvent{ .remove = .{
                     .level = table.level,
                     .table = table.table,
                 } };
+                break :remove remove;
             },
 
             .compact => ManifestEvent{ .compact = {} },
@@ -415,16 +419,17 @@ const Environment = struct {
         env.manifest_log.checkpoint(checkpoint_callback);
         env.wait(&env.manifest_log);
 
-        var vsr_state = env.manifest_log.superblock.working.vsr_state;
-        vsr_state.commit_min += 1;
-        vsr_state.commit_min_checksum += 1;
-        vsr_state.commit_max += 1;
+        const vsr_state = &env.manifest_log.superblock.working.vsr_state;
 
         env.pending += 1;
         env.manifest_log.superblock.checkpoint(
             checkpoint_superblock_callback,
             &env.superblock_context,
-            vsr_state,
+            .{
+                .commit_min_checksum = vsr_state.commit_min_checksum + 1,
+                .commit_min = vsr_state.commit_min + 1,
+                .commit_max = vsr_state.commit_max + 1,
+            },
         );
         env.wait(&env.manifest_log);
 
@@ -615,7 +620,7 @@ fn verify_manifest(
     try std.testing.expect(std.mem.eql(u64, expect.addresses[0..c], actual.addresses[0..c]));
 
     try std.testing.expect(hash_map_equals(
-        u64,
+        SuperBlock.Manifest.TableExtentKey,
         SuperBlock.Manifest.TableExtent,
         &expect.tables,
         &actual.tables,

package/src/tigerbeetle/src/lsm/merge_iterator.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-const util = @import("../util.zig");
+const stdx = @import("../stdx.zig");
 
 const k_max = 2;