tigerbeetle-node 0.11.2 → 0.11.3

package/dist/.client.node.sha256

@@ -1 +1 @@
-5e64232ef290c0ed5f8b48762a2f9d03683e4a2ac5d74fc06ea594c035ec4b8b  dist/client.node
+cd58e7f1a46beef96d550cfb8423c01542980ff7f9832127e73ad2e5cd0e3a63  dist/client.node

package/package.json

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

package/src/tigerbeetle/src/config.zig

@@ -2,6 +2,8 @@ const std = @import("std");
 const assert = std.debug.assert;
 const vsr = @import("vsr.zig");
 
+const build_options = @import("tigerbeetle_build_options");
+
 const Environment = enum {
     development,
     production,
@@ -330,6 +332,10 @@ pub const verify = true;
 pub const journal_size_headers = journal_slot_count * @sizeOf(vsr.Header);
 pub const journal_size_prepares = journal_slot_count * message_size_max;
 
+// Which backend to use for ./tracer.zig.
+// Default is `.none`.
+pub const tracer_backend = build_options.tracer_backend;
+
 // TODO Move these into a separate `config_valid.zig` which we import here:
 comptime {
     // vsr.parse_address assumes that config.address/config.port are valid.

package/src/tigerbeetle/src/ewah.zig

@@ -160,6 +160,24 @@ pub fn ewah(comptime Word: type) type {
     };
 }
 
+test "ewah encode→decode cycle" {
+    const fuzz = @import("./ewah_fuzz.zig");
+    var prng = std.rand.DefaultPrng.init(123);
+
+    inline for (.{ u8, u16, u32, u64, usize }) |Word| {
+        var decoded: [4096]Word = undefined;
+
+        std.mem.set(Word, &decoded, 0);
+        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
+
+        std.mem.set(Word, &decoded, std.math.maxInt(Word));
+        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
+
+        prng.random().bytes(std.mem.asBytes(&decoded));
+        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
+    }
+}
+
 test "ewah Word=u8 decode→encode→decode" {
     try test_decode_with_word(u8);
 
@@ -179,35 +197,6 @@ test "ewah Word=u8 decode→encode→decode" {
     }
 }
 
-test "ewah Word=u8 encode→decode→encode" {
-    const codec = ewah(u8);
-
-    var seed: u64 = undefined;
-    try std.os.getrandom(mem.asBytes(&seed));
-
-    var prng = std.rand.DefaultPrng.init(seed);
-    const random = prng.random();
-
-    var decoded_expect: [4096]u8 = undefined;
-    var decoded_actual: [4096]u8 = undefined;
-
-    const encoded_actual = try std.testing.allocator.alignedAlloc(
-        u8,
-        @alignOf(u8),
-        codec.encode_size_max(decoded_expect.len),
-    );
-    defer std.testing.allocator.free(encoded_actual);
-
-    var t: usize = 0;
-    while (t < 100) : (t += 1) {
-        random.bytes(decoded_expect[0..]);
-        _ = codec.encode(decoded_expect[0..], encoded_actual);
-        const decoded_actual_length = codec.decode(encoded_actual[0..], decoded_actual[0..]);
-        try std.testing.expectEqual(decoded_expect.len, decoded_actual_length);
-        try std.testing.expectEqual(decoded_expect, decoded_actual);
-    }
-}
-
 test "ewah Word=u16" {
     try test_decode_with_word(u16);
 }

package/src/tigerbeetle/src/ewah_fuzz.zig

@@ -0,0 +1,128 @@
+//! Fuzz EWAH encode/decode cycle.
+const std = @import("std");
+const assert = std.debug.assert;
+const log = std.log.scoped(.fuzz_ewah);
+
+const ewah = @import("./ewah.zig");
+const fuzz = @import("./test/fuzz.zig");
+
+pub fn main() !void {
+    const allocator = std.testing.allocator;
+    const args = try fuzz.parse_fuzz_args(allocator);
+
+    inline for (.{ u8, u16, u32, u64, usize }) |Word| {
+        var prng = std.rand.DefaultPrng.init(args.seed);
+        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 = try allocator.alloc(Word, decoded_size);
+        defer allocator.free(decoded);
+
+        const decoded_bits_total = decoded_size * @bitSizeOf(Word);
+        const decoded_bits = random.uintLessThan(usize, decoded_bits_total);
+        generate_bits(random, std.mem.sliceAsBytes(decoded[0..decoded_size]), decoded_bits);
+
+        var context = try ContextType(Word).init(allocator, decoded.len);
+        defer context.deinit(allocator);
+
+        const encoded_size = try context.test_encode_decode(decoded);
+
+        log.info("word={} decoded={} encoded={} compression_ratio={d:.2} set={d:.2}", .{
+            Word,
+            decoded_size,
+            encoded_size,
+            @intToFloat(f64, decoded_size) / @intToFloat(f64, encoded_size),
+            @intToFloat(f64, decoded_bits) / @intToFloat(f64, decoded_bits_total),
+        });
+    }
+}
+
+pub fn fuzz_encode_decode(
+    comptime Word: type,
+    allocator: std.mem.Allocator,
+    decoded: []const Word,
+) !void {
+    var context = try ContextType(Word).init(allocator, decoded.len);
+    defer context.deinit(allocator);
+
+    _ = try context.test_encode_decode(decoded);
+}
+
+/// Modify `data` such that it has exactly `bits_set_total` randomly-chosen bits set,
+/// with the remaining bits unset.
+fn generate_bits(random: std.rand.Random, data: []u8, bits_set_total: usize) void {
+    const bits_total = data.len * @bitSizeOf(u8);
+    assert(bits_set_total <= bits_total);
+
+    // Start off full or empty to save some work.
+    const init_empty = bits_set_total < @divExact(bits_total, 2);
+    std.mem.set(u8, data, if (init_empty) @as(u8, 0) else std.math.maxInt(u8));
+
+    var bits_set = if (init_empty) 0 else bits_total;
+    while (bits_set != bits_set_total) {
+        const bit = random.uintLessThan(usize, bits_total);
+        const word = @divFloor(bit, @bitSizeOf(u8));
+        const mask = @as(u8, 1) << @intCast(std.math.Log2Int(u8), bit % @bitSizeOf(u8));
+
+        if (init_empty) {
+            if (data[word] & mask != 0) continue;
+            data[word] |= mask;
+            bits_set += 1;
+        } else {
+            if (data[word] & mask == 0) continue;
+            data[word] &= ~mask;
+            bits_set -= 1;
+        }
+    }
+}
+
+fn ContextType(comptime Word: type) type {
+    return struct {
+        const Self = @This();
+        const Codec = ewah.ewah(Word);
+
+        decoded_actual: []Word,
+        encoded_actual: []align(@alignOf(Word)) u8,
+
+        fn init(allocator: std.mem.Allocator, size_max: usize) !Self {
+            const decoded_actual = try allocator.alloc(Word, size_max);
+            errdefer allocator.free(decoded_actual);
+
+            const encoded_actual = try allocator.alignedAlloc(
+                u8,
+                @alignOf(Word),
+                Codec.encode_size_max(size_max),
+            );
+            errdefer allocator.free(encoded_actual);
+
+            return Self{
+                .decoded_actual = decoded_actual,
+                .encoded_actual = encoded_actual,
+            };
+        }
+
+        fn deinit(context: *Self, allocator: std.mem.Allocator) void {
+            allocator.free(context.decoded_actual);
+            allocator.free(context.encoded_actual);
+        }
+
+        fn test_encode_decode(context: Self, decoded_expect: []const Word) !usize {
+            assert(decoded_expect.len > 0);
+
+            const encoded_size = Codec.encode(decoded_expect, context.encoded_actual);
+            const decoded_actual_size = Codec.decode(
+                context.encoded_actual[0..encoded_size],
+                context.decoded_actual[0..],
+            );
+
+            try std.testing.expectEqual(decoded_expect.len, decoded_actual_size);
+            try std.testing.expectEqualSlices(
+                Word,
+                decoded_expect,
+                context.decoded_actual[0..decoded_actual_size],
+            );
+            return encoded_size;
+        }
+    };
+}

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

@@ -36,6 +36,8 @@ const math = std.math;
 const assert = std.debug.assert;
 
 const log = std.log.scoped(.compaction);
+const tracer = @import("../tracer.zig");
+
 const config = @import("../config.zig");
 
 const GridType = @import("grid.zig").GridType;
@@ -120,6 +122,8 @@ pub fn CompactionType(
             done,
         };
 
+        tree_name: []const u8,
+
         grid: *Grid,
         grid_reservation: Grid.Reservation,
         range: Manifest.CompactionRange,
@@ -155,7 +159,9 @@ pub fn CompactionType(
 
         tables_output_count: usize = 0,
 
-        pub fn init(allocator: mem.Allocator) !Compaction {
+        tracer_slot: ?tracer.SpanStart = null,
+
+        pub fn init(allocator: mem.Allocator, tree_name: []const u8) !Compaction {
             var iterator_a = try IteratorA.init(allocator);
             errdefer iterator_a.deinit(allocator);
 
@@ -166,6 +172,8 @@ pub fn CompactionType(
             errdefer table_builder.deinit(allocator);
 
             return Compaction{
+                .tree_name = tree_name,
+
                 // Assigned by start()
                 .grid = undefined,
                 .grid_reservation = undefined,
@@ -216,6 +224,7 @@ pub fn CompactionType(
             assert(compaction.callback == null);
             assert(compaction.io_pending == 0);
             assert(!compaction.merge_done and compaction.merge_iterator == null);
+            assert(compaction.tracer_slot == null);
 
             assert(op_min % @divExact(config.lsm_batch_multiple, 2) == 0);
             assert(range.table_count > 0);
@@ -230,6 +239,8 @@ pub fn CompactionType(
             assert(drop_tombstones or level_b < config.lsm_levels - 1);
 
             compaction.* = .{
+                .tree_name = compaction.tree_name,
+
                 .grid = grid,
                 // Reserve enough blocks to write our output tables in the worst case, where:
                 // - no tombstones are dropped,
@@ -337,6 +348,15 @@ pub fn CompactionType(
 
             compaction.callback = callback;
 
+            tracer.start(
+                &compaction.tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_tick = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+            );
+
             // Generate fake IO to make sure io_pending doesn't reach zero multiple times from
             // IO being completed inline down below.
             // The fake IO is immediately resolved and triggers the cpu_merge_start if all
@@ -405,6 +425,16 @@ pub fn CompactionType(
             assert(compaction.io_pending == 0);
             assert(!compaction.merge_done);
 
+            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,
+                } },
+            );
+
             // 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) {
@@ -422,6 +452,23 @@ pub fn CompactionType(
                 compaction.cpu_merge_finish();
             }
 
+            tracer.end(
+                &tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_merge = .{
+                    .tree_name = compaction.tree_name,
+                    .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,
+                } },
+            );
+
             // TODO Implement pacing here by deciding if we should do another compact_tick()
             // instead of invoking the callback, using compaction.range.table_count as the heuristic.
 
@@ -560,6 +607,7 @@ pub fn CompactionType(
             assert(compaction.callback == null);
             assert(compaction.io_pending == 0);
             assert(compaction.merge_done);
+            assert(compaction.tracer_slot == null);
 
             // TODO(Beat Pacing) This should really be where the compaction callback is invoked,
             // but currently that can occur multiple times per beat.

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

@@ -6,7 +6,9 @@ const assert = std.debug.assert;
 const config = @import("../config.zig");
 const fuzz = @import("../test/fuzz.zig");
 const vsr = @import("../vsr.zig");
+
 const log = std.log.scoped(.lsm_forest_fuzz);
+const tracer = @import("../tracer.zig");
 
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Transfer = @import("../tigerbeetle.zig").Transfer;
@@ -395,6 +397,9 @@ pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
 }
 
 pub fn main() !void {
+    try tracer.init(allocator);
+    defer tracer.deinit(allocator);
+
     const fuzz_args = try fuzz.parse_fuzz_args(allocator);
     var rng = std.rand.DefaultPrng.init(fuzz_args.seed);
     const random = rng.random();

package/src/tigerbeetle/src/lsm/tree.zig

@@ -7,6 +7,7 @@ const mem = std.mem;
 const os = std.os;
 
 const log = std.log.scoped(.tree);
+const tracer = @import("../tracer.zig");
 
 const config = @import("../config.zig");
 const div_ceil = @import("../util.zig").div_ceil;
@@ -144,6 +145,8 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
         checkpoint_callback: ?fn (*Tree) void,
         open_callback: ?fn (*Tree) void,
 
+        tracer_slot: ?tracer.SpanStart = null,
+
         pub const Options = struct {
             /// The maximum number of keys that may be committed per batch.
             ///
@@ -188,13 +191,13 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             var manifest = try Manifest.init(allocator, node_pool, grid, tree_hash);
             errdefer manifest.deinit(allocator);
 
-            var compaction_table_immutable = try CompactionTableImmutable.init(allocator);
+            var compaction_table_immutable = try CompactionTableImmutable.init(allocator, tree_name);
             errdefer compaction_table_immutable.deinit(allocator);
 
             var compaction_table: [@divFloor(config.lsm_levels, 2)]CompactionTable = undefined;
             for (compaction_table) |*compaction, i| {
                 errdefer for (compaction_table[0..i]) |*c| c.deinit(allocator);
-                compaction.* = try CompactionTable.init(allocator);
+                compaction.* = try CompactionTable.init(allocator, tree_name);
             }
             errdefer for (compaction_table) |*c| c.deinit(allocator);
 
@@ -221,6 +224,8 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
         }
 
         pub fn deinit(tree: *Tree, allocator: mem.Allocator) void {
+            assert(tree.tracer_slot == null);
+
             tree.compaction_table_immutable.deinit(allocator);
             for (tree.compaction_table) |*compaction| compaction.deinit(allocator);
 
@@ -548,6 +553,12 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             assert(tree.compaction_io_pending == 0);
             assert(tree.compaction_callback == null);
 
+            tracer.start(
+                &tree.tracer_slot,
+                .{ .tree = .{ .tree_name = tree_name } },
+                .{ .tree_compaction_beat = .{ .tree_name = tree_name } },
+            );
+
             tree.compaction_callback = callback;
 
             const compaction_beat = tree.compaction_op % config.lsm_batch_multiple;
@@ -917,6 +928,12 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             assert(tree.compaction_io_pending == 0);
             assert(tree.table_mutable.can_commit_batch(tree.options.commit_entries_max));
 
+            tracer.end(
+                &tree.tracer_slot,
+                .{ .tree = .{ .tree_name = tree_name } },
+                .{ .tree_compaction_beat = .{ .tree_name = tree_name } },
+            );
+
             // Invoke the compact() callback after the manifest compacts at the end of the beat.
             const callback = tree.compaction_callback.?;
             tree.compaction_callback = null;

package/src/tigerbeetle/src/lsm/tree_fuzz.zig

@@ -6,7 +6,9 @@ const assert = std.debug.assert;
 const config = @import("../config.zig");
 const fuzz = @import("../test/fuzz.zig");
 const vsr = @import("../vsr.zig");
+
 const log = std.log.scoped(.lsm_tree_fuzz);
+const tracer = @import("../tracer.zig");
 
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Transfer = @import("../tigerbeetle.zig").Transfer;
@@ -27,7 +29,7 @@ const Table = @import("table.zig").TableType(
     Key.tombstone,
     Key.tombstone_from_key,
 );
-const Tree = @import("tree.zig").TreeType(Table, Storage, @typeName(Table) ++ "_test");
+const Tree = @import("tree.zig").TreeType(Table, Storage, "Key.Value");
 
 const Grid = GridType(Storage);
 const SuperBlock = vsr.SuperBlockType(Storage);
@@ -440,6 +442,9 @@ pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
 }
 
 pub fn main() !void {
+    try tracer.init(allocator);
+    defer tracer.deinit(allocator);
+
     const fuzz_args = try fuzz.parse_fuzz_args(allocator);
     var rng = std.rand.DefaultPrng.init(fuzz_args.seed);
     const random = rng.random();

package/src/tigerbeetle/src/main.zig

@@ -9,6 +9,7 @@ const log = std.log.scoped(.main);
 const build_options = @import("tigerbeetle_build_options");
 const config = @import("config.zig");
 pub const log_level: std.log.Level = @intToEnum(std.log.Level, config.log_level);
+const tracer = @import("tracer.zig");
 
 const cli = @import("cli.zig");
 const fatal = cli.fatal;
@@ -130,6 +131,9 @@ const Command = struct {
     ) !void {
         const allocator = arena.allocator();
 
+        try tracer.init(allocator);
+        defer tracer.deinit(allocator);
+
         var command: Command = undefined;
         try command.init(allocator, path, false);
         defer command.deinit(allocator);

package/src/tigerbeetle/src/simulator.zig

@@ -333,7 +333,7 @@ pub fn main() !void {
         var crashes = cluster.replica_normal_count() -| replica_normal_min;
 
         for (cluster.storages) |*storage, replica| {
-            if (cluster.replicas[replica].journal.recovered) {
+            if (cluster.replicas[replica].journal.status == .recovered) {
                 // TODO Remove this workaround when VSR recovery protocol is disabled.
                 // When only the minimum number of replicas are healthy (no more crashes allowed),
                 // disable storage faults on all healthy replicas.

package/src/tigerbeetle/src/state_machine.zig

@@ -2,7 +2,9 @@ const std = @import("std");
 const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
+
 const log = std.log.scoped(.state_machine);
+const tracer = @import("tracer.zig");
 
 const tb = @import("tigerbeetle.zig");
 const snapshot_latest = @import("lsm/tree.zig").snapshot_latest;
@@ -114,6 +116,8 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
         compact_callback: ?fn (*StateMachine) void = null,
         checkpoint_callback: ?fn (*StateMachine) void = null,
 
+        tracer_slot: ?tracer.SpanStart,
+
         pub fn init(allocator: mem.Allocator, grid: *Grid, options: Options) !StateMachine {
             var forest = try Forest.init(
                 allocator,
@@ -127,10 +131,13 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
                 .prepare_timestamp = 0,
                 .commit_timestamp = 0,
                 .forest = forest,
+                .tracer_slot = null,
             };
         }
 
         pub fn deinit(self: *StateMachine, allocator: mem.Allocator) void {
+            assert(self.tracer_slot == null);
+
             self.forest.deinit(allocator);
         }
 
@@ -218,6 +225,12 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
                 return;
             }
 
+            tracer.start(
+                &self.tracer_slot,
+                .main,
+                .state_machine_prefetch,
+            );
+
             self.prefetch_input = input;
             self.prefetch_callback = callback;
 
@@ -248,6 +261,13 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
             const callback = self.prefetch_callback.?;
             self.prefetch_input = null;
             self.prefetch_callback = null;
+
+            tracer.end(
+                &self.tracer_slot,
+                .main,
+                .state_machine_prefetch,
+            );
+
             callback(self);
         }
 
@@ -367,6 +387,12 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
             _ = client;
             assert(op != 0);
 
+            tracer.start(
+                &self.tracer_slot,
+                .main,
+                .state_machine_commit,
+            );
+
             const result = switch (operation) {
                 .root => unreachable,
                 .register => 0,
@@ -377,6 +403,12 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
                 else => unreachable,
             };
 
+            tracer.end(
+                &self.tracer_slot,
+                .main,
+                .state_machine_commit,
+            );
+
             return result;
         }
 
@@ -384,6 +416,12 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
             assert(self.compact_callback == null);
             assert(self.checkpoint_callback == null);
 
+            tracer.start(
+                &self.tracer_slot,
+                .main,
+                .state_machine_compact,
+            );
+
             self.compact_callback = callback;
             self.forest.compact(compact_finish, op);
         }
@@ -392,6 +430,13 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
             const self = @fieldParentPtr(StateMachine, "forest", forest);
             const callback = self.compact_callback.?;
             self.compact_callback = null;
+
+            tracer.end(
+                &self.tracer_slot,
+                .main,
+                .state_machine_compact,
+            );
+
             callback(self);
         }
 

package/src/tigerbeetle/src/test/state_checker.zig

@@ -72,7 +72,7 @@ pub const StateChecker = struct {
     pub fn check_state(state_checker: *StateChecker, replica_index: u8) !void {
         const replica = state_checker.replicas[replica_index];
         const commit_header = header: {
-            if (replica.journal.recovered) {
+            if (replica.journal.status == .recovered) {
                 const commit_header = replica.journal.header_with_op(replica.commit_min);
                 assert(commit_header != null or replica.commit_min == replica.op_checkpoint);
                 break :header replica.journal.header_with_op(replica.commit_min);

package/src/tigerbeetle/src/test/storage.zig

@@ -751,6 +751,15 @@ pub const Storage = struct {
         }
     }
 
+    pub fn superblock_sector(
+        storage: *const Storage,
+        copy_: u8,
+    ) *const superblock.SuperBlockSector {
+        const offset = vsr.Zone.superblock.offset(superblock.Layout.offset_sector(copy_));
+        const bytes = storage.memory[offset..][0..@sizeOf(superblock.SuperBlockSector)];
+        return mem.bytesAsValue(superblock.SuperBlockSector, bytes);
+    }
+
     pub fn wal_headers(storage: *const Storage) []const vsr.Header {
         const offset = vsr.Zone.wal_headers.offset(0);
         const size = vsr.Zone.wal_headers.size().?;