tigerbeetle-node 0.9.0 → 0.10.0

package/src/tigerbeetle/src/ring_buffer.zig

@@ -1,12 +1,24 @@
 const std = @import("std");
 const assert = std.debug.assert;
+const math = std.math;
+const mem = std.mem;
 
 /// A First In, First Out ring buffer holding at most `count_max` elements.
-pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
+pub fn RingBuffer(
+    comptime T: type,
+    comptime count_max: usize,
+    comptime buffer_type: enum { array, pointer },
+) type {
     return struct {
         const Self = @This();
 
-        buffer: [count_max]T = undefined,
+        buffer: switch (buffer_type) {
+            .array => [count_max]T,
+            .pointer => *[count_max]T,
+        } = switch (buffer_type) {
+            .array => undefined,
+            .pointer => @compileError("init() must be used if buffer_type is .pointer!"),
+        },
 
         /// The index of the slot with the first item, if any.
         index: usize = 0,
@@ -14,7 +26,22 @@ pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
         /// The number of items in the buffer.
         count: usize = 0,
 
-        // TODO add doc comments to these functions:
+        pub usingnamespace switch (buffer_type) {
+            .array => struct {},
+            .pointer => struct {
+                pub fn init(allocator: mem.Allocator) !Self {
+                    const buffer = try allocator.create([count_max]T);
+                    errdefer allocator.destroy(buffer);
+                    return Self{ .buffer = buffer };
+                }
+
+                pub fn deinit(self: *Self, allocator: mem.Allocator) void {
+                    allocator.destroy(self.buffer);
+                }
+            },
+        };
+
+        // TODO Add doc comments to these functions:
         pub inline fn head(self: Self) ?T {
             if (self.empty()) return null;
             return self.buffer[self.index];
@@ -25,6 +52,11 @@ pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
             return &self.buffer[self.index];
         }
 
+        pub inline fn head_ptr_const(self: *const Self) ?*const T {
+            if (self.empty()) return null;
+            return &self.buffer[self.index];
+        }
+
         pub inline fn tail(self: Self) ?T {
             if (self.empty()) return null;
             return self.buffer[(self.index + self.count - 1) % self.buffer.len];
@@ -35,6 +67,11 @@ pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
             return &self.buffer[(self.index + self.count - 1) % self.buffer.len];
         }
 
+        pub inline fn tail_ptr_const(self: *const Self) ?*const T {
+            if (self.empty()) return null;
+            return &self.buffer[(self.index + self.count - 1) % self.buffer.len];
+        }
+
         pub inline fn get_ptr(self: *Self, index: usize) ?*T {
             if (index < self.count) {
                 return &self.buffer[(self.index + index) % self.buffer.len];
@@ -54,6 +91,11 @@ pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
             return &self.buffer[(self.index + self.count) % self.buffer.len];
         }
 
+        pub inline fn next_tail_ptr_const(self: *const Self) ?*const T {
+            if (self.full()) return null;
+            return &self.buffer[(self.index + self.count) % self.buffer.len];
+        }
+
         pub inline fn advance_head(self: *Self) void {
             self.index += 1;
             self.index %= self.buffer.len;
@@ -96,6 +138,19 @@ pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
             };
         }
 
+        pub fn push_slice(self: *Self, items: []const T) error{NoSpaceLeft}!void {
+            if (self.count + items.len > self.buffer.len) return error.NoSpaceLeft;
+
+            const pre_wrap_start = (self.index + self.count) % self.buffer.len;
+            const pre_wrap_count = math.min(items.len, self.buffer.len - pre_wrap_start);
+            const post_wrap_count = items.len - pre_wrap_count;
+
+            mem.copy(T, self.buffer[pre_wrap_start..], items[0..pre_wrap_count]);
+            mem.copy(T, self.buffer[0..post_wrap_count], items[pre_wrap_count..]);
+
+            self.count += items.len;
+        }
+
         /// Remove and return the next item, if any.
         pub fn pop(self: *Self) ?T {
             const result = self.head() orelse return null;
@@ -111,17 +166,18 @@ pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
         }
 
         pub const Iterator = struct {
-            ring: *Self,
+            ring: *const Self,
             count: usize = 0,
 
             pub fn next(it: *Iterator) ?T {
+                // TODO Use next_ptr() internally to avoid duplicating this code.
                 assert(it.count <= it.ring.count);
                 if (it.count == it.ring.count) return null;
                 defer it.count += 1;
                 return it.ring.buffer[(it.ring.index + it.count) % it.ring.buffer.len];
             }
 
-            pub fn next_ptr(it: *Iterator) ?*T {
+            pub fn next_ptr(it: *Iterator) ?*const T {
                 assert(it.count <= it.ring.count);
                 if (it.count == it.ring.count) return null;
                 defer it.count += 1;
@@ -130,8 +186,25 @@ pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
         };
 
         /// Returns an iterator to iterate through all `count` items in the ring buffer.
-        /// The iterator is invalidated and unsafe if the ring buffer is modified.
-        pub fn iterator(self: *Self) Iterator {
+        /// The iterator is invalidated if the ring buffer is advanced.
+        pub fn iterator(self: *const Self) Iterator {
+            return .{ .ring = self };
+        }
+
+        pub const IteratorMutable = struct {
+            ring: *Self,
+            count: usize = 0,
+
+            pub fn next_ptr(it: *IteratorMutable) ?*T {
+                assert(it.count <= it.ring.count);
+                if (it.count == it.ring.count) return null;
+                defer it.count += 1;
+                return &it.ring.buffer[(it.ring.index + it.count) % it.ring.buffer.len];
+            }
+        };
+
+        // TODO Add to tests.
+        pub fn iterator_mutable(self: *Self) IteratorMutable {
             return .{ .ring = self };
         }
     };
@@ -156,11 +229,30 @@ fn test_iterator(comptime T: type, ring: *T, values: []const u32) !void {
     try testing.expectEqual(ring_index, ring.index);
 }
 
-test "RingBuffer: low level interface" {
-    const Ring = RingBuffer(u32, 2);
+fn test_low_level_interface(comptime Ring: type, ring: *Ring) !void {
+    try ring.push_slice(&[_]u32{});
+    try test_iterator(Ring, ring, &[_]u32{});
+
+    try testing.expectError(error.NoSpaceLeft, ring.push_slice(&[_]u32{ 1, 2, 3 }));
 
-    var ring = Ring{};
-    try test_iterator(Ring, &ring, &[_]u32{});
+    try ring.push_slice(&[_]u32{1});
+    try testing.expectEqual(@as(?u32, 1), ring.tail());
+    try testing.expectEqual(@as(u32, 1), ring.tail_ptr().?.*);
+    ring.advance_head();
+
+    try testing.expectEqual(@as(usize, 1), ring.index);
+    try testing.expectEqual(@as(usize, 0), ring.count);
+    try ring.push_slice(&[_]u32{ 1, 2 });
+    try test_iterator(Ring, ring, &[_]u32{ 1, 2 });
+    ring.advance_head();
+    ring.advance_head();
+
+    try testing.expectEqual(@as(usize, 1), ring.index);
+    try testing.expectEqual(@as(usize, 0), ring.count);
+    try ring.push_slice(&[_]u32{1});
+    try testing.expectEqual(@as(?u32, 1), ring.tail());
+    try testing.expectEqual(@as(u32, 1), ring.tail_ptr().?.*);
+    ring.advance_head();
 
     try testing.expectEqual(@as(?u32, null), ring.head());
     try testing.expectEqual(@as(?*u32, null), ring.head_ptr());
@@ -171,13 +263,13 @@ test "RingBuffer: low level interface" {
     ring.advance_tail();
     try testing.expectEqual(@as(?u32, 0), ring.tail());
     try testing.expectEqual(@as(u32, 0), ring.tail_ptr().?.*);
-    try test_iterator(Ring, &ring, &[_]u32{0});
+    try test_iterator(Ring, ring, &[_]u32{0});
 
     ring.next_tail_ptr().?.* = 1;
     ring.advance_tail();
     try testing.expectEqual(@as(?u32, 1), ring.tail());
     try testing.expectEqual(@as(u32, 1), ring.tail_ptr().?.*);
-    try test_iterator(Ring, &ring, &[_]u32{ 0, 1 });
+    try test_iterator(Ring, ring, &[_]u32{ 0, 1 });
 
     try testing.expectEqual(@as(?u32, null), ring.next_tail());
     try testing.expectEqual(@as(?*u32, null), ring.next_tail_ptr());
@@ -185,39 +277,32 @@ test "RingBuffer: low level interface" {
     try testing.expectEqual(@as(?u32, 0), ring.head());
     try testing.expectEqual(@as(u32, 0), ring.head_ptr().?.*);
     ring.advance_head();
-    try test_iterator(Ring, &ring, &[_]u32{1});
+    try test_iterator(Ring, ring, &[_]u32{1});
 
     ring.next_tail_ptr().?.* = 2;
     ring.advance_tail();
     try testing.expectEqual(@as(?u32, 2), ring.tail());
     try testing.expectEqual(@as(u32, 2), ring.tail_ptr().?.*);
-    try test_iterator(Ring, &ring, &[_]u32{ 1, 2 });
-
-    var iterator = ring.iterator();
-    while (iterator.next_ptr()) |item_ptr| {
-        item_ptr.* += 1000;
-    }
+    try test_iterator(Ring, ring, &[_]u32{ 1, 2 });
 
-    try testing.expectEqual(@as(?u32, 1001), ring.head());
-    try testing.expectEqual(@as(u32, 1001), ring.head_ptr().?.*);
     ring.advance_head();
-    try test_iterator(Ring, &ring, &[_]u32{1002});
+    try test_iterator(Ring, ring, &[_]u32{2});
 
     ring.next_tail_ptr().?.* = 3;
     ring.advance_tail();
     try testing.expectEqual(@as(?u32, 3), ring.tail());
     try testing.expectEqual(@as(u32, 3), ring.tail_ptr().?.*);
-    try test_iterator(Ring, &ring, &[_]u32{ 1002, 3 });
+    try test_iterator(Ring, ring, &[_]u32{ 2, 3 });
 
-    try testing.expectEqual(@as(?u32, 1002), ring.head());
-    try testing.expectEqual(@as(u32, 1002), ring.head_ptr().?.*);
+    try testing.expectEqual(@as(?u32, 2), ring.head());
+    try testing.expectEqual(@as(u32, 2), ring.head_ptr().?.*);
     ring.advance_head();
-    try test_iterator(Ring, &ring, &[_]u32{3});
+    try test_iterator(Ring, ring, &[_]u32{3});
 
     try testing.expectEqual(@as(?u32, 3), ring.head());
     try testing.expectEqual(@as(u32, 3), ring.head_ptr().?.*);
     ring.advance_head();
-    try test_iterator(Ring, &ring, &[_]u32{});
+    try test_iterator(Ring, ring, &[_]u32{});
 
     try testing.expectEqual(@as(?u32, null), ring.head());
     try testing.expectEqual(@as(?*u32, null), ring.head_ptr());
@@ -225,8 +310,19 @@ test "RingBuffer: low level interface" {
     try testing.expectEqual(@as(?*u32, null), ring.tail_ptr());
 }
 
+test "RingBuffer: low level interface" {
+    const ArrayRing = RingBuffer(u32, 2, .array);
+    var array_ring: ArrayRing = .{};
+    try test_low_level_interface(ArrayRing, &array_ring);
+
+    const PointerRing = RingBuffer(u32, 2, .pointer);
+    var pointer_ring = try PointerRing.init(testing.allocator);
+    defer pointer_ring.deinit(testing.allocator);
+    try test_low_level_interface(PointerRing, &pointer_ring);
+}
+
 test "RingBuffer: push/pop high level interface" {
-    var fifo = RingBuffer(u32, 3){};
+    var fifo = RingBuffer(u32, 3, .array){};
 
     try testing.expect(!fifo.full());
     try testing.expect(fifo.empty());
@@ -273,7 +369,7 @@ test "RingBuffer: push/pop high level interface" {
 }
 
 test "RingBuffer: pop_tail" {
-    var lifo = RingBuffer(u32, 3){};
+    var lifo = RingBuffer(u32, 3, .array){};
     try lifo.push(1);
     try lifo.push(2);
     try lifo.push(3);

package/src/tigerbeetle/src/simulator.zig

@@ -7,6 +7,7 @@ const config = @import("config.zig");
 
 const Client = @import("test/cluster.zig").Client;
 const Cluster = @import("test/cluster.zig").Cluster;
+const ClusterOptions = @import("test/cluster.zig").ClusterOptions;
 const Header = @import("vsr.zig").Header;
 const Replica = @import("test/cluster.zig").Replica;
 const StateChecker = @import("test/state_checker.zig").StateChecker;
@@ -21,13 +22,23 @@ const output = std.log.scoped(.state_checker);
 const log_state_transitions_only = builtin.mode != .Debug;
 
 const log_health = std.log.scoped(.health);
+const log_faults = std.log.scoped(.faults);
 
 /// You can fine tune your log levels even further (debug/info/notice/warn/err/crit/alert/emerg):
 pub const log_level: std.log.Level = if (log_state_transitions_only) .info else .debug;
 
+/// Modifies compile-time constants on "config.zig".
+pub const deployment_environment = .simulation;
+comptime {
+    assert(config.deployment_environment == .simulation);
+}
+
 var cluster: *Cluster = undefined;
 
 pub fn main() !void {
+    // This must be initialized at runtime as stderr is not comptime known on e.g. Windows.
+    log_buffer.unbuffered_writer = std.io.getStdErr().writer();
+
     // TODO Use std.testing.allocator when all deinit() leaks are fixed.
     const allocator = std.heap.page_allocator;
 
@@ -70,11 +81,12 @@ pub fn main() !void {
     const idle_on_probability = random.uintLessThan(u8, 20);
     const idle_off_probability = 10 + random.uintLessThan(u8, 10);
 
-    cluster = try Cluster.create(allocator, random, .{
+    const cluster_options: ClusterOptions = .{
         .cluster = 0,
         .replica_count = replica_count,
         .client_count = client_count,
         .seed = random.int(u64),
+        .on_change_state = on_change_replica,
         .network_options = .{
             .packet_simulator_options = .{
                 .replica_count = replica_count,
@@ -112,16 +124,13 @@ pub fn main() !void {
             .restart_probability = 0.01,
             .restart_stability = random.uintLessThan(u32, 1_000),
         },
-    });
-    defer cluster.destroy();
-
-    cluster.state_checker = try StateChecker.init(allocator, cluster);
-    defer cluster.state_checker.deinit();
-
-    for (cluster.replicas) |*replica| {
-        replica.on_change_state = on_change_replica;
-    }
-    cluster.on_change_state = on_change_replica;
+        .state_machine_options = .{
+            .seed = random.int(u64),
+            .prefetch_mean = 5 + random.uintLessThan(u64, 10),
+            .compact_mean = 5 + random.uintLessThan(u64, 10),
+            .checkpoint_mean = 5 + random.uintLessThan(u64, 10),
+        },
+    };
 
     output.info(
         \\
@@ -154,6 +163,9 @@ pub fn main() !void {
         \\          crash_stability={} ticks
         \\          restart_probability={d}%
         \\          restart_stability={} ticks
+        \\          prefetch_mean={} ticks
+        \\          compact_mean={} ticks
+        \\          checkpoint_mean={} ticks
         \\
     , .{
         seed,
@@ -162,30 +174,39 @@ pub fn main() !void {
         request_probability,
         idle_on_probability,
         idle_off_probability,
-        cluster.options.network_options.packet_simulator_options.one_way_delay_mean,
-        cluster.options.network_options.packet_simulator_options.one_way_delay_min,
-        cluster.options.network_options.packet_simulator_options.packet_loss_probability,
-        cluster.options.network_options.packet_simulator_options.path_maximum_capacity,
-        cluster.options.network_options.packet_simulator_options.path_clog_duration_mean,
-        cluster.options.network_options.packet_simulator_options.path_clog_probability,
-        cluster.options.network_options.packet_simulator_options.packet_replay_probability,
-        cluster.options.network_options.packet_simulator_options.partition_mode,
-        cluster.options.network_options.packet_simulator_options.partition_probability,
-        cluster.options.network_options.packet_simulator_options.unpartition_probability,
-        cluster.options.network_options.packet_simulator_options.partition_stability,
-        cluster.options.network_options.packet_simulator_options.unpartition_stability,
-        cluster.options.storage_options.read_latency_min,
-        cluster.options.storage_options.read_latency_mean,
-        cluster.options.storage_options.write_latency_min,
-        cluster.options.storage_options.write_latency_mean,
-        cluster.options.storage_options.read_fault_probability,
-        cluster.options.storage_options.write_fault_probability,
-        cluster.options.health_options.crash_probability * 100,
-        cluster.options.health_options.crash_stability,
-        cluster.options.health_options.restart_probability * 100,
-        cluster.options.health_options.restart_stability,
+        cluster_options.network_options.packet_simulator_options.one_way_delay_mean,
+        cluster_options.network_options.packet_simulator_options.one_way_delay_min,
+        cluster_options.network_options.packet_simulator_options.packet_loss_probability,
+        cluster_options.network_options.packet_simulator_options.path_maximum_capacity,
+        cluster_options.network_options.packet_simulator_options.path_clog_duration_mean,
+        cluster_options.network_options.packet_simulator_options.path_clog_probability,
+        cluster_options.network_options.packet_simulator_options.packet_replay_probability,
+        cluster_options.network_options.packet_simulator_options.partition_mode,
+        cluster_options.network_options.packet_simulator_options.partition_probability,
+        cluster_options.network_options.packet_simulator_options.unpartition_probability,
+        cluster_options.network_options.packet_simulator_options.partition_stability,
+        cluster_options.network_options.packet_simulator_options.unpartition_stability,
+        cluster_options.storage_options.read_latency_min,
+        cluster_options.storage_options.read_latency_mean,
+        cluster_options.storage_options.write_latency_min,
+        cluster_options.storage_options.write_latency_mean,
+        cluster_options.storage_options.read_fault_probability,
+        cluster_options.storage_options.write_fault_probability,
+        cluster_options.health_options.crash_probability * 100,
+        cluster_options.health_options.crash_stability,
+        cluster_options.health_options.restart_probability * 100,
+        cluster_options.health_options.restart_stability,
+        cluster_options.state_machine_options.prefetch_mean,
+        cluster_options.state_machine_options.compact_mean,
+        cluster_options.state_machine_options.checkpoint_mean,
     });
 
+    cluster = try Cluster.create(allocator, random, cluster_options);
+    defer cluster.destroy();
+
+    cluster.state_checker = try StateChecker.init(allocator, cluster);
+    defer cluster.state_checker.deinit();
+
     var requests_sent: u64 = 0;
     var idle = false;
 
@@ -215,7 +236,6 @@ pub fn main() !void {
 
         for (cluster.storages) |*storage, replica| {
             if (cluster.replicas[replica].journal.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.
@@ -226,11 +246,17 @@ pub fn main() !void {
                 // because two replicas are not enough to nack, and the unhealthy replica cannot
                 // complete the VSR recovery protocol either.
                 if (cluster.health[replica] == .up and crashes == 0) {
-                    storage.faulty = false;
+                    if (storage.faulty) {
+                        log_faults.debug("{}: disable storage faults", .{replica});
+                        storage.faulty = false;
+                    }
                 } else {
                     // When a journal recovers for the first time, enable its storage faults.
                     // Future crashes will recover in the presence of faults.
-                    storage.faulty = true;
+                    if (!storage.faulty) {
+                        log_faults.debug("{}: enable storage faults", .{replica});
+                        storage.faulty = true;
+                    }
                 }
             }
             storage.tick();
@@ -252,7 +278,7 @@ pub fn main() !void {
                     }
 
                     if (!try cluster.crash_replica(replica.replica)) continue;
-                    log_health.debug("crash replica={}", .{replica.replica});
+                    log_health.debug("{}: crash replica", .{replica.replica});
                     crashes -= 1;
                 },
                 .down => |*ticks| {
@@ -263,7 +289,7 @@ pub fn main() !void {
                     assert(replica.status == .recovering);
                     if (ticks.* == 0 and chance_f64(random, health_options.restart_probability)) {
                         cluster.health[replica.replica] = .{ .up = health_options.restart_stability };
-                        log_health.debug("restart replica={}", .{replica.replica});
+                        log_health.debug("{}: restart replica", .{replica.replica});
                     }
                 },
             }
@@ -325,7 +351,6 @@ fn args_next(args: *std.process.ArgIterator, allocator: std.mem.Allocator) ?[:0]
 }
 
 fn on_change_replica(replica: *Replica) void {
-    assert(cluster.state_machines[replica.replica].state == replica.state_machine.state);
     cluster.state_checker.check_state(replica.replica);
 }
 
@@ -398,6 +423,11 @@ fn parse_seed(bytes: []const u8) u64 {
     };
 }
 
+var log_buffer: std.io.BufferedWriter(4096, std.fs.File.Writer) = .{
+    // This is initialized in main(), as std.io.getStdErr() is not comptime known on e.g. Windows.
+    .unbuffered_writer = undefined,
+};
+
 pub fn log(
     comptime level: std.log.Level,
     comptime scope: @TypeOf(.EnumLiteral),
@@ -409,9 +439,11 @@ pub fn log(
     const prefix_default = "[" ++ @tagName(level) ++ "] " ++ "(" ++ @tagName(scope) ++ "): ";
     const prefix = if (log_state_transitions_only) "" else prefix_default;
 
-    // Print the message to stdout, silently ignoring any errors
-    const stderr = std.io.getStdErr().writer();
-    std.debug.getStderrMutex().lock();
-    defer std.debug.getStderrMutex().unlock();
-    nosuspend stderr.print(prefix ++ format ++ "\n", args) catch return;
+    // Print the message to stderr using a buffer to avoid many small write() syscalls when
+    // providing many format arguments. Silently ignore failure.
+    log_buffer.writer().print(prefix ++ format ++ "\n", args) catch {};
+
+    // Flush the buffer before returning to ensure, for example, that a log message
+    // immediately before a failing assertion is fully printed.
+    log_buffer.flush() catch {};
 }