tigerbeetle-node 0.11.8 → 0.11.10

package/dist/.client.node.sha256

@@ -1 +1 @@
-c82197101574fc1267be050abfa7d31ca355036eec3f7d3da9a43a6c83bf6b0c  dist/client.node
+21c6105d76e0efc68fe5cbe799d363a083a9b44359e16d7dbfbb172e381ea0c3  dist/client.node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tigerbeetle-node",
-  "version": "0.11.8",
+  "version": "0.11.10",
   "description": "TigerBeetle Node.js client",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -18,13 +18,14 @@
     "package.json",
     "package-lock.json",
     "scripts/download_node_headers.sh",
+    "scripts/build_lib.sh",
     "src/c.zig",
     "src/benchmark.ts",
     "src/index.ts",
     "src/node.zig",
     "src/test.ts",
     "src/tigerbeetle/src/*.zig",
-    "src/tigerbeetle/src/{c,io,lsm,test,vsr,state_machine}",
+    "src/tigerbeetle/src/{c,io,lsm,testing,vsr,state_machine}",
     "src/tigerbeetle/scripts",
     "src/translate.zig",
     "tsconfig.json"
@@ -40,7 +41,7 @@
     "download_node_headers": "sh ./scripts/download_node_headers.sh",
     "build": "npm run build_tsc && npm run build_lib",
     "build_tsc": "./node_modules/typescript/bin/tsc",
-    "build_lib": "mkdir -p dist && zig/zig build-lib -mcpu=baseline -OReleaseSafe -dynamic -lc -isystem build/node-$(node --version)/include/node src/node.zig -fallow-shlib-undefined -femit-bin=dist/client.node",
+    "build_lib": "sh ./scripts/build_lib.sh",
     "prepack": "npm run build_tsc",
     "clean": "rm -rf build dist node_modules src/zig-cache zig"
   },

package/scripts/build_lib.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env sh
+
+set -e
+
+# macOS 13 Ventura is not supported on Zig 0.9.x.
+# Overriding -target is one workaround Andrew suggests.
+# https://github.com/ziglang/zig/issues/10478#issuecomment-1294313967
+target=""
+if [ "$(./zig/zig targets | grep triple |cut -d '"' -f 4 | cut -d '.' -f 1,2)" = "aarch64-macos.13" ]; then
+    target="-target native-macos.11"
+fi
+
+# Zig picks musl libc on RHEL instead of glibc, incorrectly
+# https://github.com/ziglang/zig/issues/12156
+if [ -f "/etc/redhat-release" ]; then
+   if ! grep Fedora /etc/redhat-release; then
+       target="-target native-native-gnu"
+   fi
+fi
+
+if [ "$target" = "" ]; then
+    echo "Building default target"
+else
+    echo "Building for '$target'"
+fi
+
+mkdir -p dist
+
+# Need to do string eval-ing because of shellcheck's strict string
+# interpolation rules.
+cmd="./zig/zig build-lib \
+	-mcpu=baseline \
+	-OReleaseSafe \
+	-dynamic \
+	-lc \
+	-isystem build/node-$(node --version)/include/node \
+	-fallow-shlib-undefined \
+	-femit-bin=dist/client.node \
+        $target src/node.zig"
+
+eval "$cmd"

package/src/node.zig

@@ -161,7 +161,7 @@ const Context = struct {
                 .io = context.io,
             },
         );
-        defer context.client.deinit(allocator);
+        errdefer context.client.deinit(allocator);
 
         return try translate.create_external(env, context);
     }

package/src/tigerbeetle/scripts/validate_docs.sh

@@ -13,5 +13,11 @@ if [[ -z "$BRANCH" ]]; then
     # Otherwise fall back to git rev-parse
     BRANCH=$(git rev-parse --abbrev-ref HEAD)
 fi
-( cd docs_website && npm install && ./scripts/build.sh "$BRANCH" )
+
+REPO="https://github.com/tigerbeetledb/tigerbeetle"
+if [[ -n "$SOURCE_REPO" ]]; then
+    REPO="${SOURCE_REPO}"
+fi
+
+( cd docs_website && npm install && ./scripts/build.sh "$BRANCH" "$REPO" )
 rm -rf docs_website

package/src/tigerbeetle/src/benchmark.zig

@@ -8,7 +8,7 @@ pub const log_level: std.log.Level = .err;
 
 const IO = @import("io.zig").IO;
 
-const util = @import("util.zig");
+const stdx = @import("stdx.zig");
 const Storage = @import("storage.zig").Storage;
 const MessagePool = @import("message_pool.zig").MessagePool;
 const MessageBus = @import("message_bus.zig").MessageBusClient;
@@ -211,7 +211,7 @@ const TimedQueue = struct {
             const message = self.client.get_message();
             defer self.client.unref(message);
 
-            util.copy_disjoint(
+            stdx.copy_disjoint(
                 .inexact,
                 u8,
                 message.buffer[@sizeOf(vsr.Header)..],
@@ -279,7 +279,7 @@ const TimedQueue = struct {
             const message = self.client.get_message();
             defer self.client.unref(message);
 
-            util.copy_disjoint(
+            stdx.copy_disjoint(
                 .inexact,
                 u8,
                 message.buffer[@sizeOf(vsr.Header)..],

package/src/tigerbeetle/src/config.zig

@@ -1,8 +1,18 @@
+//! Raw configuration values.
+//!
+//! Code which needs these values should use `constants.zig` instead.
+//! Configuration values are set from a combination of:
+//! - default values
+//! - `root.tigerbeetle_config`
+//! - `@import("tigerbeetle_options")`
+
 const builtin = @import("builtin");
 const std = @import("std");
 
-const build_options = @import("tigerbeetle_build_options");
 const root = @import("root");
+// Allow setting build-time config either via `build.zig` `Options`, or via a struct in the root file.
+const build_options =
+    if (@hasDecl(root, "vsr_options")) root.vsr_options else @import("vsr_options");
 
 const vsr = @import("vsr.zig");
 const sector_size = @import("constants.zig").sector_size;
@@ -25,6 +35,7 @@ pub const Config = struct {
 const ConfigProcess = struct {
     log_level: std.log.Level = .info,
     tracer_backend: TracerBackend = .none,
+    hash_log_mode: HashLogMode = .none,
     verify: bool,
     port: u16 = 3001,
     address: []const u8 = "127.0.0.1",
@@ -68,6 +79,8 @@ const ConfigProcess = struct {
 const ConfigCluster = struct {
     cache_line_size: comptime_int = 64,
     clients_max: usize,
+    pipeline_prepare_queue_max: usize = 8,
+    view_change_headers_max: usize = 8,
     quorum_replication_max: u8 = 3,
     journal_slot_count: usize = 1024,
     message_size_max: usize = 1 * 1024 * 1024,
@@ -80,7 +93,6 @@ const ConfigCluster = struct {
     lsm_batch_multiple: comptime_int = 4,
     lsm_snapshots_max: usize = 32,
     lsm_value_to_key_layout_ratio_min: comptime_int = 16,
-    state_machine: StateMachine = .accounting,
 
     /// The WAL requires at least two sectors of redundant headers — otherwise we could lose them all to
     /// a single torn write. A replica needs at least one valid redundant header to determine an
@@ -91,7 +103,7 @@ const ConfigCluster = struct {
     pub const clients_max_min = 1;
 
     /// The smallest possible message_size_max (for use in the simulator to improve performance).
-    /// The message body must have room for pipeline_max headers in the DVC.
+    /// The message body must have room for pipeline_prepare_queue_max headers in the DVC.
     pub fn message_size_max_min(clients_max: usize) usize {
         return std.math.max(
             sector_size,
@@ -118,9 +130,10 @@ pub const TracerBackend = enum {
     tracy,
 };
 
-pub const StateMachine = enum {
-    accounting,
-    testing,
+pub const HashLogMode = enum {
+    none,
+    create,
+    check,
 };
 
 pub const configs = struct {
@@ -166,10 +179,12 @@ pub const configs = struct {
             .verify = true,
         },
         .cluster = .{
-            .clients_max = 4,
+            .clients_max = 4 + 3,
+            .pipeline_prepare_queue_max = 4,
+            .view_change_headers_max = 4,
             .journal_slot_count = Config.Cluster.journal_slot_count_min,
-            .message_size_max = Config.Cluster.message_size_max_min(2),
-            .storage_size_max = 1024 * 1024 * 1024,
+            .message_size_max = Config.Cluster.message_size_max_min(4),
+            .storage_size_max = 4 * 1024 * 1024 * 1024,
 
             .block_size = sector_size,
             .lsm_growth_factor = 4,
@@ -196,13 +211,6 @@ pub const configs = struct {
             .test_min => test_min,
         };
 
-        base.cluster.state_machine = if (@hasDecl(root, "decode_events"))
-            // TODO(DJ) This is a hack to work around the absense of tigerbeetle_build_options.
-            // This should be removed once the node client is built using `zig build`.
-            .accounting
-        else
-            @intToEnum(StateMachine, @enumToInt(build_options.config_cluster_state_machine));
-
         // TODO Use additional build options to overwrite other fields.
         base.process.tracer_backend = if (@hasDecl(root, "tracer_backend"))
             // TODO(jamii)
@@ -214,6 +222,13 @@ pub const configs = struct {
             // but a different type from a nominal typing perspective.
             @intToEnum(TracerBackend, @enumToInt(build_options.tracer_backend));
 
+        base.process.hash_log_mode = if (@hasDecl(root, "decode_events"))
+            // TODO(DJ) This is a hack to work around the absense of tigerbeetle_build_options.
+            // This should be removed once the node client is built using `zig build`.
+            .none
+        else
+            @intToEnum(HashLogMode, @enumToInt(build_options.hash_log_mode));
+
         break :current base;
     };
 };

package/src/tigerbeetle/src/constants.zig

@@ -1,3 +1,7 @@
+//! Constants are the configuration that the code actually imports — they include:
+//! - all of the configuration values (flattened)
+//! - derived configuration values,
+
 const std = @import("std");
 const assert = std.debug.assert;
 const vsr = @import("vsr.zig");
@@ -18,15 +22,12 @@ else
 // Default is `.none`.
 pub const tracer_backend = config.process.tracer_backend;
 
+// Which mode to use for ./testing/hash_log.zig.
+pub const hash_log_mode = config.process.hash_log_mode;
+
 /// The maximum number of replicas allowed in a cluster.
 pub const replicas_max = 6;
 
-pub const state_machine = config.cluster.state_machine;
-pub const StateMachineType = switch (config.cluster.state_machine) {
-    .accounting => @import("state_machine.zig").StateMachineType,
-    .testing => @import("test/state_machine.zig").StateMachineType,
-};
-
 /// The maximum number of clients allowed per cluster, where each client has a unique 128-bit ID.
 /// This impacts the amount of memory allocated at initialization by the server.
 /// This determines the size of the VR client table used to cache replies to clients by client ID.
@@ -131,7 +132,7 @@ comptime {
     assert(journal_slot_count >= Config.Cluster.journal_slot_count_min);
     assert(journal_slot_count >= lsm_batch_multiple * 2);
     assert(journal_slot_count % lsm_batch_multiple == 0);
-    assert(journal_size_max == journal_size_headers + journal_size_prepares);
+    assert(journal_slot_count > pipeline_prepare_queue_max);
 
     assert(journal_size_max == journal_size_headers + journal_size_prepares);
 }
@@ -156,12 +157,50 @@ comptime {
     assert(message_size_max >= @sizeOf(vsr.Header));
     assert(message_size_max >= sector_size);
     assert(message_size_max >= Config.Cluster.message_size_max_min(clients_max));
+
+    // Ensure that DVC/SV messages can fit all necessary headers.
+    assert(message_body_size_max >= view_change_headers_max * @sizeOf(vsr.Header));
 }
 
 /// The maximum number of Viewstamped Replication prepare messages that can be inflight at a time.
 /// This is immutable once assigned per cluster, as replicas need to know how many operations might
 /// possibly be uncommitted during a view change, and this must be constant for all replicas.
-pub const pipeline_max = clients_max;
+pub const pipeline_prepare_queue_max = config.cluster.pipeline_prepare_queue_max;
+
+/// The maximum number of Viewstamped Replication request messages that can be queued at a primary,
+/// waiting to prepare.
+// TODO(Zig): After 0.10, change this to simply "clients_max -| pipeline_prepare_queue_max".
+// In Zig 0.9 compilation fails with "operation caused overflow" despite the saturating subtraction.
+// See: https://github.com/ziglang/zig/issues/10870
+pub const pipeline_request_queue_max =
+    if (clients_max < pipeline_prepare_queue_max)
+    0
+else
+    clients_max - pipeline_prepare_queue_max;
+
+comptime {
+    // A prepare-queue capacity larger than clients_max is wasted.
+    assert(pipeline_prepare_queue_max <= clients_max);
+    // A total queue capacity larger than clients_max is wasted.
+    assert(pipeline_prepare_queue_max + pipeline_request_queue_max <= clients_max);
+    assert(pipeline_prepare_queue_max > 0);
+    assert(pipeline_request_queue_max >= 0);
+}
+
+/// The number of prepare headers to include in the body of a DVC/SV.
+///
+/// CRITICAL:
+/// We must provide enough headers to cover all uncommitted headers so that the new
+/// primary (if we are in a view change) can decide whether to discard uncommitted headers
+/// that cannot be repaired because they are gaps. See DVCQuorum for more detail.
+pub const view_change_headers_max = config.cluster.view_change_headers_max;
+
+comptime {
+    assert(view_change_headers_max > 0);
+    assert(view_change_headers_max >= pipeline_prepare_queue_max);
+    assert(view_change_headers_max <= journal_slot_count);
+    assert(view_change_headers_max <= @divFloor(message_body_size_max, @sizeOf(vsr.Header)));
+}
 
 /// The minimum and maximum amount of time in milliseconds to wait before initiating a connection.
 /// Exponential backoff and jitter are applied within this range.
@@ -263,7 +302,7 @@ pub const iops_write_max = journal_iops_write_max;
 /// The maximum number of concurrent WAL read I/O operations to allow at once.
 pub const journal_iops_read_max = config.process.journal_iops_read_max;
 /// The maximum number of concurrent WAL write I/O operations to allow at once.
-/// Ideally this is at least as high as pipeline_max, but it is safe to be lower.
+/// Ideally this is at least as high as pipeline_prepare_queue_max, but it is safe to be lower.
 pub const journal_iops_write_max = config.process.journal_iops_write_max;
 
 /// The number of redundant copies of the superblock in the superblock storage zone.

package/src/tigerbeetle/src/ewah.zig

@@ -2,9 +2,9 @@ const std = @import("std");
 const assert = std.debug.assert;
 const math = std.math;
 const mem = std.mem;
-const util = @import("util.zig");
-const div_ceil = util.div_ceil;
-const disjoint_slices = util.disjoint_slices;
+const stdx = @import("stdx.zig");
+const div_ceil = stdx.div_ceil;
+const disjoint_slices = stdx.disjoint_slices;
 
 /// Encode or decode a bitset using Daniel Lemire's EWAH codec.
 /// ("Histogram-Aware Sorting for Enhanced Word-Aligned Compression in Bitmap Indexes")
@@ -78,7 +78,7 @@ pub fn ewah(comptime Word: type) type {
                     if (marker.uniform_bit == 1) ~@as(Word, 0) else 0,
                 );
                 target_index += marker.uniform_word_count;
-                util.copy_disjoint(
+                stdx.copy_disjoint(
                     .exact,
                     Word,
                     target_words[target_index..][0..marker.literal_word_count],
@@ -129,7 +129,7 @@ pub fn ewah(comptime Word: type) type {
                     .literal_word_count = @intCast(MarkerLiteralCount, literal_word_count),
                 });
                 target_index += 1;
-                util.copy_disjoint(
+                stdx.copy_disjoint(
                     .exact,
                     Word,
                     target_words[target_index..][0..literal_word_count],

package/src/tigerbeetle/src/ewah_fuzz.zig

@@ -4,7 +4,7 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.fuzz_ewah);
 
 const ewah = @import("./ewah.zig");
-const fuzz = @import("./test/fuzz.zig");
+const fuzz = @import("./testing/fuzz.zig");
 
 pub const tigerbeetle_config = @import("config.zig").configs.test_min;
 

package/src/tigerbeetle/src/lsm/binary_search.zig

@@ -137,7 +137,7 @@ pub inline fn binary_search_keys(
 }
 
 const test_binary_search = struct {
-    const fuzz = @import("../test/fuzz.zig");
+    const fuzz = @import("../testing/fuzz.zig");
 
     const log = false;
 

package/src/tigerbeetle/src/lsm/bloom_filter.zig

@@ -82,7 +82,7 @@ test {
 }
 
 const test_bloom_filter = struct {
-    const fuzz = @import("../test/fuzz.zig");
+    const fuzz = @import("../testing/fuzz.zig");
     const block_size = @import("../constants.zig").block_size;
 
     fn random_keys(random: std.rand.Random, iter: usize) !void {

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

@@ -62,7 +62,12 @@ pub fn CompactionType(
         const BlockWrite = struct {
             write: Grid.Write = undefined,
             block: *BlockPtr = undefined,
-            writable: bool = false,
+            state: BlockState = .building,
+        };
+        const BlockState = enum {
+            building,
+            writable,
+            writing,
         };
 
         const Manifest = ManifestType(Table, Storage);
@@ -241,9 +246,9 @@ pub fn CompactionType(
                 .level_a_input = if (table_a) |table| table.* else null,
             };
 
-            assert(!compaction.index.writable);
-            assert(!compaction.filter.writable);
-            assert(!compaction.data.writable);
+            assert(compaction.index.state == .building);
+            assert(compaction.filter.state == .building);
+            assert(compaction.data.state == .building);
 
             // TODO Implement manifest.move_table() optimization if there's only range.table_count == 1.
             // This would do update_tables + insert_tables inline without going through the iterators.
@@ -342,6 +347,14 @@ pub fn CompactionType(
             const write_callback = struct {
                 fn callback(write: *Grid.Write) void {
                     const block_write = @fieldParentPtr(BlockWrite, "write", write);
+
+                    assert(block_write.state == .writing);
+                    block_write.state = .building;
+
+                    if (constants.verify) {
+                        // We've finished writing so the block should now be zeroed.
+                        assert(mem.allEqual(u8, block_write.block.*, 0));
+                    }
                     block_write.block = undefined;
 
                     const _compaction = @fieldParentPtr(Compaction, @tagName(field), block_write);
@@ -350,8 +363,8 @@ pub fn CompactionType(
             }.callback;
 
             const block_write: *BlockWrite = &@field(compaction, @tagName(field));
-            if (block_write.writable) {
-                block_write.writable = false;
+            if (block_write.state == .writable) {
+                block_write.state = .writing;
 
                 compaction.io_start();
                 compaction.grid.write_block(
@@ -405,9 +418,9 @@ pub fn CompactionType(
                 assert(!compaction.merge_iterator.?.empty());
             }
 
-            assert(!compaction.data.writable);
-            assert(!compaction.filter.writable);
-            assert(!compaction.index.writable);
+            assert(compaction.data.state == .building);
+            assert(compaction.filter.state == .building);
+            assert(compaction.index.state == .building);
 
             if (!compaction.merge_iterator.?.empty()) {
                 compaction.cpu_merge();
@@ -444,9 +457,9 @@ pub fn CompactionType(
             // Ensure there are values to merge and that is it safe to do so.
             const merge_iterator = &compaction.merge_iterator.?;
             assert(!merge_iterator.empty());
-            assert(!compaction.data.writable);
-            assert(!compaction.filter.writable);
-            assert(!compaction.index.writable);
+            assert(compaction.data.state == .building);
+            assert(compaction.filter.state == .building);
+            assert(compaction.index.state == .building);
 
             // Build up a data block with values merged from the read iterators.
             // This skips tombstone values if compaction was started with the intent to drop them.
@@ -470,8 +483,8 @@ pub fn CompactionType(
 
                 // Mark the finished data block as writable for the next compact_tick() call.
                 compaction.data.block = &compaction.table_builder.data_block;
-                assert(!compaction.data.writable);
-                compaction.data.writable = true;
+                assert(compaction.data.state == .building);
+                compaction.data.state = .writable;
             }
 
             // Finalize the filter block if it's full or if it contains pending data blocks
@@ -487,8 +500,8 @@ pub fn CompactionType(
 
                 // Mark the finished filter block as writable for the next compact_tick() call.
                 compaction.filter.block = &compaction.table_builder.filter_block;
-                assert(!compaction.filter.writable);
-                compaction.filter.writable = true;
+                assert(compaction.filter.state == .building);
+                compaction.filter.state = .writable;
             }
 
             // Finalize the index block if it's full or if it contains pending data blocks
@@ -507,8 +520,8 @@ pub fn CompactionType(
 
                 // Mark the finished index block as writable for the next compact_tick() call.
                 compaction.index.block = &compaction.table_builder.index_block;
-                assert(!compaction.index.writable);
-                compaction.index.writable = true;
+                assert(compaction.index.state == .building);
+                compaction.index.state = .writable;
 
                 compaction.tables_output_count += 1;
                 assert(compaction.tables_output_count <= compaction.range.table_count);
@@ -524,9 +537,9 @@ pub fn CompactionType(
 
             // Ensure merging is truly finished.
             assert(compaction.merge_iterator.?.empty());
-            assert(!compaction.data.writable);
-            assert(!compaction.filter.writable);
-            assert(!compaction.index.writable);
+            assert(compaction.data.state == .building);
+            assert(compaction.filter.state == .building);
+            assert(compaction.index.state == .building);
 
             // Double check the iterators are finished as well.
             const stream_empty = struct {