tigerbeetle-node 0.11.12 → 0.12.0

package/src/tigerbeetle/src/message_pool.zig

@@ -1,156 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-const mem = std.mem;
-
-const constants = @import("constants.zig");
-
-const vsr = @import("vsr.zig");
-const Header = vsr.Header;
-
-comptime {
-    // message_size_max must be a multiple of sector_size for Direct I/O
-    assert(constants.message_size_max % constants.sector_size == 0);
-}
-
-/// The number of full-sized messages allocated at initialization by the replica message pool.
-/// There must be enough messages to ensure that the replica can always progress, to avoid deadlock.
-pub const messages_max_replica = messages_max: {
-    var sum: usize = 0;
-
-    sum += constants.journal_iops_read_max; // Journal reads
-    sum += constants.journal_iops_write_max; // Journal writes
-    sum += constants.clients_max; // SuperBlock.client_table
-    sum += 1; // Replica.loopback_queue
-    sum += constants.pipeline_prepare_queue_max; // Replica.Pipeline{Queue|Cache}
-    sum += constants.pipeline_request_queue_max; // Replica.Pipeline{Queue|Cache}
-    sum += 1; // Replica.commit_prepare
-    // Replica.do_view_change_from_all_replicas quorum:
-    // Replica.recovery_response_quorum is only used for recovery and does not increase the limit.
-    // All other quorums are bitsets.
-    sum += constants.replicas_max;
-    sum += constants.connections_max; // Connection.recv_message
-    sum += constants.connections_max * constants.connection_send_queue_max_replica; // Connection.send_queue
-    sum += 1; // Handle bursts (e.g. Connection.parse_message)
-    // Handle Replica.commit_op's reply:
-    // (This is separate from the burst +1 because they may occur concurrently).
-    sum += 1;
-
-    break :messages_max sum;
-};
-
-/// The number of full-sized messages allocated at initialization by the client message pool.
-pub const messages_max_client = messages_max: {
-    var sum: usize = 0;
-
-    sum += constants.replicas_max; // Connection.recv_message
-    sum += constants.replicas_max * constants.connection_send_queue_max_client; // Connection.send_queue
-    sum += constants.client_request_queue_max; // Client.request_queue
-    // Handle bursts (e.g. Connection.parse_message, or sending a ping when the send queue is full).
-    sum += 1;
-
-    break :messages_max sum;
-};
-
-comptime {
-    // These conditions are necessary (but not sufficient) to prevent deadlocks.
-    assert(messages_max_replica > constants.replicas_max);
-    assert(messages_max_client > constants.client_request_queue_max);
-}
-
-/// A pool of reference-counted Messages, memory for which is allocated only once during
-/// initialization and reused thereafter. The messages_max values determine the size of this pool.
-pub const MessagePool = struct {
-    pub const Message = struct {
-        // TODO: replace this with a header() function to save memory
-        header: *Header,
-        buffer: *align(constants.sector_size) [constants.message_size_max]u8,
-        references: u32 = 0,
-        next: ?*Message,
-
-        /// Increment the reference count of the message and return the same pointer passed.
-        pub fn ref(message: *Message) *Message {
-            message.references += 1;
-            return message;
-        }
-
-        pub fn body(message: *const Message) []align(@sizeOf(Header)) u8 {
-            return message.buffer[@sizeOf(Header)..message.header.size];
-        }
-    };
-
-    /// List of currently unused messages.
-    free_list: ?*Message,
-
-    messages_max: usize,
-
-    pub fn init(allocator: mem.Allocator, process_type: vsr.ProcessType) error{OutOfMemory}!MessagePool {
-        return MessagePool.init_capacity(allocator, switch (process_type) {
-            .replica => messages_max_replica,
-            .client => messages_max_client,
-        });
-    }
-
-    pub fn init_capacity(allocator: mem.Allocator, messages_max: usize) error{OutOfMemory}!MessagePool {
-        var pool: MessagePool = .{
-            .free_list = null,
-            .messages_max = messages_max,
-        };
-        {
-            var i: usize = 0;
-            while (i < messages_max) : (i += 1) {
-                const buffer = try allocator.allocAdvanced(
-                    u8,
-                    constants.sector_size,
-                    constants.message_size_max,
-                    .exact,
-                );
-                const message = try allocator.create(Message);
-                message.* = .{
-                    .header = mem.bytesAsValue(Header, buffer[0..@sizeOf(Header)]),
-                    .buffer = buffer[0..constants.message_size_max],
-                    .next = pool.free_list,
-                };
-                pool.free_list = message;
-            }
-        }
-
-        return pool;
-    }
-
-    /// Frees all messages that were unused or returned to the pool via unref().
-    pub fn deinit(pool: *MessagePool, allocator: mem.Allocator) void {
-        var free_count: usize = 0;
-        while (pool.free_list) |message| {
-            pool.free_list = message.next;
-            allocator.free(@as([]const u8, message.buffer));
-            allocator.destroy(message);
-            free_count += 1;
-        }
-        // If the MessagePool is being deinitialized, all messages should have already been
-        // released to the pool.
-        assert(free_count == pool.messages_max);
-    }
-
-    /// Get an unused message with a buffer of constants.message_size_max.
-    /// The returned message has exactly one reference.
-    pub fn get_message(pool: *MessagePool) *Message {
-        const message = pool.free_list.?;
-        pool.free_list = message.next;
-        message.next = null;
-        assert(message.references == 0);
-
-        message.references = 1;
-        return message;
-    }
-
-    /// Decrement the reference count of the message, possibly freeing it.
-    pub fn unref(pool: *MessagePool, message: *Message) void {
-        message.references -= 1;
-        if (message.references == 0) {
-            mem.set(u8, message.buffer, 0);
-            message.next = pool.free_list;
-            pool.free_list = message;
-        }
-    }
-};

package/src/tigerbeetle/src/ring_buffer.zig

@@ -1,399 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const math = std.math;
-const mem = std.mem;
-
-const stdx = @import("stdx.zig");
-
-/// A First In, First Out ring buffer holding at most `count_max` elements.
-pub fn RingBuffer(
-    comptime T: type,
-    comptime count_max_: usize,
-    comptime buffer_type: enum { array, pointer },
-) type {
-    return struct {
-        const Self = @This();
-
-        pub const count_max = count_max_;
-
-        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,
-
-        /// The number of items in the buffer.
-        count: usize = 0,
-
-        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 (count_max == 0 or self.empty()) return null;
-            return self.buffer[self.index];
-        }
-
-        pub inline fn head_ptr(self: *Self) ?*T {
-            if (count_max == 0 or self.empty()) return null;
-            return &self.buffer[self.index];
-        }
-
-        pub inline fn head_ptr_const(self: *const Self) ?*const T {
-            if (count_max == 0 or self.empty()) return null;
-            return &self.buffer[self.index];
-        }
-
-        pub inline fn tail(self: Self) ?T {
-            if (count_max == 0 or self.empty()) return null;
-            return self.buffer[(self.index + self.count - 1) % self.buffer.len];
-        }
-
-        pub inline fn tail_ptr(self: *Self) ?*T {
-            if (count_max == 0 or self.empty()) return null;
-            return &self.buffer[(self.index + self.count - 1) % self.buffer.len];
-        }
-
-        pub inline fn tail_ptr_const(self: *const Self) ?*const T {
-            if (count_max == 0 or 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 (count_max == 0) unreachable;
-
-            if (index < self.count) {
-                return &self.buffer[(self.index + index) % self.buffer.len];
-            } else {
-                assert(index < count_max);
-                return null;
-            }
-        }
-
-        pub inline fn next_tail(self: Self) ?T {
-            if (count_max == 0 or self.full()) return null;
-            return self.buffer[(self.index + self.count) % self.buffer.len];
-        }
-
-        pub inline fn next_tail_ptr(self: *Self) ?*T {
-            if (count_max == 0 or self.full()) return null;
-            return &self.buffer[(self.index + self.count) % self.buffer.len];
-        }
-
-        pub inline fn next_tail_ptr_const(self: *const Self) ?*const T {
-            if (count_max == 0 or 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;
-            self.count -= 1;
-        }
-
-        pub inline fn advance_tail(self: *Self) void {
-            assert(self.count < self.buffer.len);
-            self.count += 1;
-        }
-
-        pub inline fn retreat_tail(self: *Self) void {
-            self.count -= 1;
-        }
-
-        /// Returns whether the ring buffer is completely full.
-        pub inline fn full(self: Self) bool {
-            return self.count == self.buffer.len;
-        }
-
-        /// Returns whether the ring buffer is completely empty.
-        pub inline fn empty(self: Self) bool {
-            return self.count == 0;
-        }
-
-        // Higher level, less error-prone wrappers:
-
-        /// Add an element to the RingBuffer. Returns an error if the buffer
-        /// is already full and the element could not be added.
-        pub fn push(self: *Self, item: T) error{NoSpaceLeft}!void {
-            const ptr = self.next_tail_ptr() orelse return error.NoSpaceLeft;
-            ptr.* = item;
-            self.advance_tail();
-        }
-
-        /// Add an element to a RingBuffer, and assert that the capacity is sufficient.
-        pub fn push_assume_capacity(self: *Self, item: T) void {
-            self.push(item) catch |err| switch (err) {
-                error.NoSpaceLeft => unreachable,
-            };
-        }
-
-        pub fn push_slice(self: *Self, items: []const T) error{NoSpaceLeft}!void {
-            if (count_max == 0) return error.NoSpaceLeft;
-            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;
-
-            stdx.copy_disjoint(.inexact, T, self.buffer[pre_wrap_start..], items[0..pre_wrap_count]);
-            stdx.copy_disjoint(.exact, 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;
-            self.advance_head();
-            return result;
-        }
-
-        /// Remove and return the last item, if any.
-        pub fn pop_tail(self: *Self) ?T {
-            const result = self.tail() orelse return null;
-            self.retreat_tail();
-            return result;
-        }
-
-        pub const Iterator = struct {
-            ring: *const Self,
-            count: usize = 0,
-
-            pub fn next(it: *Iterator) ?T {
-                if (count_max == 0) return null;
-                // 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) ?*const T {
-                assert(it.count <= it.ring.count);
-                if (count_max == 0) return null;
-                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];
-            }
-        };
-
-        /// Returns an iterator to iterate through all `count` items in the ring buffer.
-        /// 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 (count_max == 0) return null;
-                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 };
-        }
-    };
-}
-
-const testing = std.testing;
-
-fn test_iterator(comptime T: type, ring: *T, values: []const u32) !void {
-    const ring_index = ring.index;
-
-    var loops: usize = 0;
-    while (loops < 2) : (loops += 1) {
-        var iterator = ring.iterator();
-        var index: usize = 0;
-        while (iterator.next()) |item| {
-            try testing.expectEqual(values[index], item);
-            index += 1;
-        }
-        try testing.expectEqual(values.len, index);
-    }
-
-    try testing.expectEqual(ring_index, ring.index);
-}
-
-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 }));
-
-    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());
-    try testing.expectEqual(@as(?u32, null), ring.tail());
-    try testing.expectEqual(@as(?*u32, null), ring.tail_ptr());
-
-    ring.next_tail_ptr().?.* = 0;
-    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});
-
-    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 testing.expectEqual(@as(?u32, null), ring.next_tail());
-    try testing.expectEqual(@as(?*u32, null), ring.next_tail_ptr());
-
-    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});
-
-    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 });
-
-    ring.advance_head();
-    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{ 2, 3 });
-
-    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 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 testing.expectEqual(@as(?u32, null), ring.head());
-    try testing.expectEqual(@as(?*u32, null), ring.head_ptr());
-    try testing.expectEqual(@as(?u32, null), ring.tail());
-    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, .array){};
-
-    try testing.expect(!fifo.full());
-    try testing.expect(fifo.empty());
-    try testing.expectEqual(@as(?*u32, null), fifo.get_ptr(0));
-    try testing.expectEqual(@as(?*u32, null), fifo.get_ptr(1));
-    try testing.expectEqual(@as(?*u32, null), fifo.get_ptr(2));
-
-    try fifo.push(1);
-    try testing.expectEqual(@as(?u32, 1), fifo.head());
-    try testing.expectEqual(@as(u32, 1), fifo.get_ptr(0).?.*);
-    try testing.expectEqual(@as(?*u32, null), fifo.get_ptr(1));
-
-    try testing.expect(!fifo.full());
-    try testing.expect(!fifo.empty());
-
-    try fifo.push(2);
-    try testing.expectEqual(@as(?u32, 1), fifo.head());
-    try testing.expectEqual(@as(u32, 2), fifo.get_ptr(1).?.*);
-
-    try fifo.push(3);
-    try testing.expectError(error.NoSpaceLeft, fifo.push(4));
-
-    try testing.expect(fifo.full());
-    try testing.expect(!fifo.empty());
-
-    try testing.expectEqual(@as(?u32, 1), fifo.head());
-    try testing.expectEqual(@as(?u32, 1), fifo.pop());
-    try testing.expectEqual(@as(u32, 2), fifo.get_ptr(0).?.*);
-    try testing.expectEqual(@as(u32, 3), fifo.get_ptr(1).?.*);
-    try testing.expectEqual(@as(?*u32, null), fifo.get_ptr(2));
-
-    try testing.expect(!fifo.full());
-    try testing.expect(!fifo.empty());
-
-    try fifo.push(4);
-
-    try testing.expectEqual(@as(?u32, 2), fifo.pop());
-    try testing.expectEqual(@as(?u32, 3), fifo.pop());
-    try testing.expectEqual(@as(?u32, 4), fifo.pop());
-    try testing.expectEqual(@as(?u32, null), fifo.pop());
-
-    try testing.expect(!fifo.full());
-    try testing.expect(fifo.empty());
-}
-
-test "RingBuffer: pop_tail" {
-    var lifo = RingBuffer(u32, 3, .array){};
-    try lifo.push(1);
-    try lifo.push(2);
-    try lifo.push(3);
-    try testing.expect(lifo.full());
-
-    try testing.expectEqual(@as(?u32, 3), lifo.pop_tail());
-    try testing.expectEqual(@as(?u32, 1), lifo.head());
-    try testing.expectEqual(@as(?u32, 2), lifo.pop_tail());
-    try testing.expectEqual(@as(?u32, 1), lifo.head());
-    try testing.expectEqual(@as(?u32, 1), lifo.pop_tail());
-    try testing.expectEqual(@as(?u32, null), lifo.pop_tail());
-    try testing.expect(lifo.empty());
-}
-
-test "RingBuffer: count_max=0" {
-    std.testing.refAllDecls(RingBuffer(u32, 0, .array));
-}