tigerbeetle-node 0.11.6 → 0.11.8

package/dist/.client.node.sha256

@@ -1 +1 @@
-b80cf792efc775e33454af2ca68f6d93c2e369d29eb95509a4fae3c215019bbc  dist/client.node
+c82197101574fc1267be050abfa7d31ca355036eec3f7d3da9a43a6c83bf6b0c  dist/client.node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tigerbeetle-node",
-  "version": "0.11.6",
+  "version": "0.11.8",
   "description": "TigerBeetle Node.js client",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/tigerbeetle/scripts/benchmark.bat

@@ -27,8 +27,7 @@ echo.
 exit /b
 
 :main
-zig\zig.exe build -Drelease-safe
-move zig-out\bin\tigerbeetle.exe . >nul
+zig\zig.exe build install -Drelease-safe
 
 for /l %%i in (0, 1, 0) do (
     echo Initializing replica %%i

package/src/tigerbeetle/scripts/benchmark.sh

@@ -12,8 +12,7 @@ fi
 COLOR_RED='\033[1;31m'
 COLOR_END='\033[0m'
 
-zig/zig build -Drelease-safe
-mv zig-out/bin/tigerbeetle .
+zig/zig build install -Drelease-safe
 
 function onerror {
     if [ "$?" == "0" ]; then

package/src/tigerbeetle/scripts/install.bat

@@ -0,0 +1,7 @@
+@echo off
+setlocal enabledelayedexpansion
+
+call .\scripts\install_zig.bat
+
+echo "Building TigerBeetle..."
+.\zig\zig.exe build install -Dcpu=baseline -Drelease-safe

package/src/tigerbeetle/scripts/install.sh

@@ -14,9 +14,8 @@ set -eu
 scripts/install_zig.sh
 if [ "$debug" = "true" ]; then
     echo "Building Tigerbeetle debug..."
-    zig/zig build -Dcpu=baseline
+    zig/zig build install -Dcpu=baseline
 else
     echo "Building TigerBeetle..."
-    zig/zig build -Dcpu=baseline -Drelease-safe
+    zig/zig build install -Dcpu=baseline -Drelease-safe
 fi
-mv zig-out/bin/tigerbeetle .

package/src/tigerbeetle/src/benchmark.zig

@@ -6,7 +6,6 @@ const constants = @import("constants.zig");
 const log = std.log;
 pub const log_level: std.log.Level = .err;
 
-const cli = @import("cli.zig");
 const IO = @import("io.zig").IO;
 
 const util = @import("util.zig");
@@ -23,7 +22,7 @@ const Client = vsr.Client(StateMachine, MessageBus);
 
 const tb = @import("tigerbeetle.zig");
 
-const batches_count = 100;
+const batches_count = 1000;
 
 const transfers_per_batch: u32 = @divExact(
     constants.message_size_max - @sizeOf(vsr.Header),
@@ -151,7 +150,8 @@ pub fn main() !void {
 
     const result: i64 = @divFloor(@intCast(i64, transfers.len * 1000), ms);
     try stdout.print("============================================\n", .{});
-    try stdout.print("{} transfers per second\n\n", .{result});
+    try stdout.print("{} batches in {} ms\n", .{ batches_count, ms });
+    try stdout.print("{} transfers per second\n", .{result});
     try stdout.print("max p100 latency per {} transfers = {}ms\n", .{
         transfers_per_batch,
         queue.transfers_latency_max,

package/src/tigerbeetle/src/ewah.zig

@@ -64,7 +64,6 @@ pub fn ewah(comptime Word: type) type {
         // so that we can test invalid encodings.
         pub fn decode(source: []align(@alignOf(Word)) const u8, target_words: []Word) usize {
             assert(source.len % @sizeOf(Word) == 0);
-            assert(source.len >= @sizeOf(Marker));
             assert(disjoint_slices(u8, Word, source, target_words));
 
             const source_words = mem.bytesAsSlice(Word, source);
@@ -95,7 +94,6 @@ pub fn ewah(comptime Word: type) type {
 
         // Returns the number of bytes written to `target`.
         pub fn encode(source_words: []const Word, target: []align(@alignOf(Word)) u8) usize {
-            assert(target.len >= @sizeOf(Marker));
             assert(target.len == encode_size_max(source_words.len));
             assert(disjoint_slices(Word, u8, source_words, target));
 
@@ -149,8 +147,6 @@ pub fn ewah(comptime Word: type) type {
         /// Assumes (pessimistically) that every word will be encoded as a literal.
         pub fn encode_size_max(word_count: usize) usize {
             const marker_count = div_ceil(word_count, marker_literal_word_count_max);
-            assert(marker_count != 0);
-
             return marker_count * @sizeOf(Marker) + word_count * @sizeOf(Word);
         }
 
@@ -178,7 +174,7 @@ test "ewah encode→decode cycle" {
     }
 }
 
-test "ewah Word=u8 decode→encode→decode" {
+test "ewah Word=u8" {
     try test_decode_with_word(u8);
 
     const codec = ewah(u8);
@@ -195,6 +191,9 @@ test "ewah Word=u8 decode→encode→decode" {
             56,
         });
     }
+
+    try std.testing.expectEqual(codec.encode_size_max(0), 0);
+    try std.testing.expectEqual(codec.encode(&.{}, &.{}), 0);
 }
 
 test "ewah Word=u16" {
@@ -205,6 +204,8 @@ test "ewah Word=u16" {
 fn test_decode_with_word(comptime Word: type) !void {
     const codec = ewah(Word);
 
+    // No set bits.
+    try test_decode(Word, &.{});
     // Alternating runs, no literals.
     try test_decode(Word, &.{
         codec.marker_word(.{ .uniform_bit = 0, .uniform_word_count = 2, .literal_word_count = 0 }),

package/src/tigerbeetle/src/ewah_fuzz.zig

@@ -17,7 +17,7 @@ pub fn main() !void {
         const random = prng.random();
 
         const decoded_size_max = @divExact(1024 * 1024, @sizeOf(Word));
-        const decoded_size = 1 + random.uintLessThan(usize, decoded_size_max);
+        const decoded_size = random.uintLessThan(usize, 1 + decoded_size_max);
         const decoded = try allocator.alloc(Word, decoded_size);
         defer allocator.free(decoded);
 

package/src/tigerbeetle/src/io/darwin.zig

@@ -571,6 +571,25 @@ pub const IO = struct {
         completion: *Completion,
         nanoseconds: u63,
     ) void {
+        // Special case a zero timeout as a yield.
+        if (nanoseconds == 0) {
+            completion.* = .{
+                .next = null,
+                .context = context,
+                .operation = undefined,
+                .callback = struct {
+                    fn on_complete(_io: *IO, _completion: *Completion) void {
+                        _ = _io;
+                        const _context = @intToPtr(Context, @ptrToInt(_completion.context));
+                        callback(_context, _completion, {});
+                    }
+                }.on_complete,
+            };
+
+            self.completed.push(completion);
+            return;
+        }
+
         self.submit(
             context,
             callback,

package/src/tigerbeetle/src/io/linux.zig

@@ -819,6 +819,14 @@ pub const IO = struct {
                 },
             },
         };
+
+        // Special case a zero timeout as a yield.
+        if (nanoseconds == 0) {
+            completion.result = -@intCast(i32, @enumToInt(std.os.E.TIME));
+            self.completed.push(completion);
+            return;
+        }
+
         self.enqueue(completion);
     }
 

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

@@ -61,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,
         };
 
@@ -85,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,
@@ -124,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);
 
@@ -135,7 +136,7 @@ pub fn CompactionType(
             errdefer table_builder.deinit(allocator);
 
             return Compaction{
-                .tree_name = tree_name,
+                .name = name,
 
                 // Assigned by start()
                 .grid = undefined,
@@ -202,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:
@@ -313,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(),
             );
 
@@ -360,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.*),
                 );
             }
         }
@@ -392,11 +390,8 @@ 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(),
             );
 
@@ -422,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()
@@ -480,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;
             }
@@ -497,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;
             }
@@ -517,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

@@ -46,8 +46,7 @@ const Environment = struct {
     // 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,
@@ -93,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);
@@ -121,7 +124,7 @@ const Environment = struct {
     }
 
     fn tick(env: *Environment) void {
-        env.grid.tick();
+        // env.grid.tick();
         env.storage.tick();
     }
 
@@ -147,7 +150,6 @@ const Environment = struct {
         env.superblock.format(superblock_format_callback, &env.superblock_context, .{
             .cluster = cluster,
             .replica = replica,
-            .storage_size_max = constants.storage_size_max,
         });
         env.tick_until_state_change(.init, .formatted);
     }
@@ -260,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);
                 },