tigerbeetle-node 0.11.5 → 0.11.7

package/src/tigerbeetle/src/io/windows.zig

@@ -62,7 +62,7 @@ pub const IO = struct {
     };
 
     fn flush(self: *IO, mode: FlushMode) !void {
-        if (self.completed.peek() == null) {
+        if (self.completed.empty()) {
             // Compute how long to poll by flushing timeout completions.
             // NOTE: this may push to completed queue
             var timeout_ms: ?os.windows.DWORD = null;
@@ -78,7 +78,7 @@ pub const IO = struct {
             }
 
             // Poll for IO iff theres IO pending and flush_timeouts() found no ready completions
-            if (self.io_pending > 0 and self.completed.peek() == null) {
+            if (self.io_pending > 0 and self.completed.empty()) {
                 // In blocking mode, we're always waiting at least until the timeout by run_for_ns.
                 // In non-blocking mode, we shouldn't wait at all.
                 const io_timeout = switch (mode) {
@@ -868,6 +868,24 @@ pub const IO = struct {
         completion: *Completion,
         nanoseconds: u63,
     ) void {
+        // Special case a zero timeout as a yield.
+        if (nanoseconds == 0) {
+            completion.* = .{
+                .next = null,
+                .context = @ptrCast(?*anyopaque, context),
+                .operation = undefined,
+                .callback = struct {
+                    fn on_complete(ctx: Completion.Context) void {
+                        const _context = @intToPtr(Context, @ptrToInt(ctx.completion.context));
+                        callback(_context, ctx.completion, {});
+                    }
+                }.on_complete,
+            };
+
+            self.completed.push(completion);
+            return;
+        }
+
         self.submit(
             context,
             callback,

package/src/tigerbeetle/src/iops.zig

@@ -19,11 +19,17 @@ pub fn IOPS(comptime T: type, comptime size: u6) type {
 
         pub fn release(self: *Self, item: *T) void {
             item.* = undefined;
-            const i = (@ptrToInt(item) - @ptrToInt(&self.items)) / @sizeOf(T);
+            const i = self.index(item);
             assert(!self.free.isSet(i));
             self.free.set(i);
         }
 
+        pub fn index(self: *Self, item: *T) usize {
+            const i = (@ptrToInt(item) - @ptrToInt(&self.items)) / @sizeOf(T);
+            assert(i < size);
+            return i;
+        }
+
         /// Returns the count of IOPs available.
         pub fn available(self: *const Self) usize {
             return self.free.count();

package/src/tigerbeetle/src/lsm/compaction.zig

@@ -42,7 +42,7 @@ const constants = @import("../constants.zig");
 
 const GridType = @import("grid.zig").GridType;
 const ManifestType = @import("manifest.zig").ManifestType;
-const KWayMergeIterator = @import("k_way_merge.zig").KWayMergeIterator;
+const MergeIteratorType = @import("merge_iterator.zig").MergeIteratorType;
 const TableIteratorType = @import("table_iterator.zig").TableIteratorType;
 const LevelIteratorType = @import("level_iterator.zig").LevelIteratorType;
 
@@ -51,8 +51,6 @@ pub fn CompactionType(
     comptime Storage: type,
     comptime IteratorAType: anytype,
 ) type {
-    const Key = Table.Key;
-    const Value = Table.Value;
     const tombstone = Table.tombstone;
 
     return struct {
@@ -63,7 +61,7 @@ pub fn CompactionType(
         const BlockPtrConst = Grid.BlockPtrConst;
         const BlockWrite = struct {
             write: Grid.Write = undefined,
-            block: BlockPtr = undefined,
+            block: *BlockPtr = undefined,
             writable: bool = false,
         };
 
@@ -73,47 +71,12 @@ pub fn CompactionType(
         const IteratorA = IteratorAType(Table, Storage);
         const IteratorB = LevelIteratorType(Table, Storage);
 
-        const k = 2;
-        const MergeIterator = KWayMergeIterator(
-            Compaction,
-            Table.Key,
-            Table.Value,
-            Table.key_from_value,
-            Table.compare_keys,
-            k,
-            MergeStreamSelector.peek,
-            MergeStreamSelector.pop,
-            MergeStreamSelector.precedence,
+        const MergeIterator = MergeIteratorType(
+            Table,
+            IteratorA,
+            IteratorB,
         );
 
-        const MergeStreamSelector = struct {
-            fn peek(compaction: *const Compaction, stream_id: u32) error{ Empty, Drained }!Key {
-                return switch (stream_id) {
-                    0 => compaction.iterator_a.peek(),
-                    1 => compaction.iterator_b.peek(),
-                    else => unreachable,
-                };
-            }
-
-            fn pop(compaction: *Compaction, stream_id: u32) Value {
-                return switch (stream_id) {
-                    0 => compaction.iterator_a.pop(),
-                    1 => compaction.iterator_b.pop(),
-                    else => unreachable,
-                };
-            }
-
-            /// Returns true if stream A has higher precedence than stream B.
-            /// This is used to deduplicate values across streams.
-            fn precedence(compaction: *const Compaction, stream_a: u32, stream_b: u32) bool {
-                _ = compaction;
-                assert(stream_a + stream_b == 1);
-
-                // All tables in iterator_a (stream=0) have a higher precedence.
-                return stream_a == 0;
-            }
-        };
-
         pub const Callback = fn (it: *Compaction) void;
 
         const Status = enum {
@@ -122,7 +85,8 @@ pub fn CompactionType(
             done,
         };
 
-        tree_name: [:0]const u8,
+        /// Used only for debugging/tracing.
+        name: [:0]const u8,
 
         grid: *Grid,
         grid_reservation: Grid.Reservation,
@@ -161,7 +125,7 @@ pub fn CompactionType(
 
         tracer_slot: ?tracer.SpanStart = null,
 
-        pub fn init(allocator: mem.Allocator, tree_name: [:0]const u8) !Compaction {
+        pub fn init(allocator: mem.Allocator, name: [:0]const u8) !Compaction {
             var iterator_a = try IteratorA.init(allocator);
             errdefer iterator_a.deinit(allocator);
 
@@ -172,7 +136,7 @@ pub fn CompactionType(
             errdefer table_builder.deinit(allocator);
 
             return Compaction{
-                .tree_name = tree_name,
+                .name = name,
 
                 // Assigned by start()
                 .grid = undefined,
@@ -239,7 +203,7 @@ pub fn CompactionType(
             assert(drop_tombstones or level_b < constants.lsm_levels - 1);
 
             compaction.* = .{
-                .tree_name = compaction.tree_name,
+                .name = compaction.name,
 
                 .grid = grid,
                 // Reserve enough blocks to write our output tables in the worst case, where:
@@ -350,11 +314,8 @@ pub fn CompactionType(
 
             tracer.start(
                 &compaction.tracer_slot,
-                .{ .tree = .{ .tree_name = compaction.tree_name } },
-                .{ .tree_compaction_tick = .{
-                    .tree_name = compaction.tree_name,
-                    .level_b = compaction.level_b,
-                } },
+                .{ .tree_compaction = .{ .compaction_name = compaction.name } },
+                .{ .tree_compaction_tick = .{ .level_b = compaction.level_b } },
                 @src(),
             );
 
@@ -397,7 +358,7 @@ pub fn CompactionType(
                     write_callback,
                     &block_write.write,
                     block_write.block,
-                    Table.block_address(block_write.block),
+                    Table.block_address(block_write.block.*),
                 );
             }
         }
@@ -429,18 +390,18 @@ pub fn CompactionType(
             var tracer_slot: ?tracer.SpanStart = null;
             tracer.start(
                 &tracer_slot,
-                .{ .tree = .{ .tree_name = compaction.tree_name } },
-                .{ .tree_compaction_merge = .{
-                    .tree_name = compaction.tree_name,
-                    .level_b = compaction.level_b,
-                } },
+                .{ .tree_compaction = .{ .compaction_name = compaction.name } },
+                .{ .tree_compaction_merge = .{ .level_b = compaction.level_b } },
                 @src(),
             );
 
             // Create the merge iterator only when we can peek() from the read iterators.
             // This happens after IO for the first reads complete.
             if (compaction.merge_iterator == null) {
-                compaction.merge_iterator = MergeIterator.init(compaction, k, .ascending);
+                compaction.merge_iterator = MergeIterator.init(
+                    &compaction.iterator_a,
+                    &compaction.iterator_b,
+                );
                 assert(!compaction.merge_iterator.?.empty());
             }
 
@@ -456,19 +417,13 @@ pub fn CompactionType(
 
             tracer.end(
                 &tracer_slot,
-                .{ .tree = .{ .tree_name = compaction.tree_name } },
-                .{ .tree_compaction_merge = .{
-                    .tree_name = compaction.tree_name,
-                    .level_b = compaction.level_b,
-                } },
+                .{ .tree_compaction = .{ .compaction_name = compaction.name } },
+                .{ .tree_compaction_merge = .{ .level_b = compaction.level_b } },
             );
             tracer.end(
                 &compaction.tracer_slot,
-                .{ .tree = .{ .tree_name = compaction.tree_name } },
-                .{ .tree_compaction_tick = .{
-                    .tree_name = compaction.tree_name,
-                    .level_b = compaction.level_b,
-                } },
+                .{ .tree_compaction = .{ .compaction_name = compaction.name } },
+                .{ .tree_compaction_tick = .{ .level_b = compaction.level_b } },
             );
 
             // TODO Implement pacing here by deciding if we should do another compact_tick()
@@ -514,7 +469,7 @@ pub fn CompactionType(
                 });
 
                 // Mark the finished data block as writable for the next compact_tick() call.
-                compaction.data.block = compaction.table_builder.data_block;
+                compaction.data.block = &compaction.table_builder.data_block;
                 assert(!compaction.data.writable);
                 compaction.data.writable = true;
             }
@@ -531,7 +486,7 @@ pub fn CompactionType(
                 });
 
                 // Mark the finished filter block as writable for the next compact_tick() call.
-                compaction.filter.block = compaction.table_builder.filter_block;
+                compaction.filter.block = &compaction.table_builder.filter_block;
                 assert(!compaction.filter.writable);
                 compaction.filter.writable = true;
             }
@@ -551,7 +506,7 @@ pub fn CompactionType(
                 compaction.manifest.insert_table(compaction.level_b, &table);
 
                 // Mark the finished index block as writable for the next compact_tick() call.
-                compaction.index.block = compaction.table_builder.index_block;
+                compaction.index.block = &compaction.table_builder.index_block;
                 assert(!compaction.index.writable);
                 compaction.index.writable = true;
 

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

@@ -41,18 +41,12 @@ const FuzzOpTag = std.meta.Tag(FuzzOp);
 const Environment = struct {
     const cluster = 32;
     const replica = 4;
-    // TODO Is this appropriate for the number of fuzz_ops we want to run?
-    const size_max = vsr.Zone.superblock.size().? +
-        vsr.Zone.wal_headers.size().? +
-        vsr.Zone.wal_prepares.size().? +
-        1024 * 1024 * 1024;
 
     const node_count = 1024;
     // This is the smallest size that set_associative_cache will allow us.
     const cache_entries_max = 2048;
     const forest_options = StateMachine.forest_options(.{
-        // Ignored by StateMachine.forest_options().
-        .lsm_forest_node_count = undefined,
+        .lsm_forest_node_count = node_count,
         .cache_entries_accounts = cache_entries_max,
         .cache_entries_transfers = cache_entries_max,
         .cache_entries_posted = cache_entries_max,
@@ -98,7 +92,11 @@ const Environment = struct {
         env.message_pool = try MessagePool.init(allocator, .replica);
         errdefer env.message_pool.deinit(allocator);
 
-        env.superblock = try SuperBlock.init(allocator, env.storage, &env.message_pool);
+        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);
 
         env.grid = try Grid.init(allocator, &env.superblock);
@@ -126,7 +124,7 @@ const Environment = struct {
     }
 
     fn tick(env: *Environment) void {
-        env.grid.tick();
+        // env.grid.tick();
         env.storage.tick();
     }
 
@@ -152,7 +150,6 @@ const Environment = struct {
         env.superblock.format(superblock_format_callback, &env.superblock_context, .{
             .cluster = cluster,
             .replica = replica,
-            .size_max = size_max,
         });
         env.tick_until_state_change(.init, .formatted);
     }
@@ -265,6 +262,8 @@ const Environment = struct {
                     if (compact.checkpoint) env.checkpoint(compact.op);
                 },
                 .put_account => |account| {
+                    // The forest requires prefetch before put.
+                    env.prefetch_account(account.id);
                     env.forest.grooves.accounts.put(&account);
                     try model.put(account.id, account);
                 },
@@ -292,7 +291,7 @@ const Environment = struct {
 
 pub fn run_fuzz_ops(storage_options: Storage.Options, fuzz_ops: []const FuzzOp) !void {
     // Init mocked storage.
-    var storage = try Storage.init(allocator, Environment.size_max, storage_options);
+    var storage = try Storage.init(allocator, constants.storage_size_max, storage_options);
     defer storage.deinit(allocator);
 
     try Environment.format(&storage);