tigerbeetle-node 0.8.1 → 0.9.143

package/src/tigerbeetle/src/message_pool.zig

@@ -1,142 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-const mem = std.mem;
-
-const config = @import("config.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(config.message_size_max % config.sector_size == 0);
-}
-
-/// Add an extra sector_size bytes to allow a partially received subsequent
-/// message to be shifted to make space for 0 padding to vsr.sector_ceil.
-const message_size_max_padded = config.message_size_max + config.sector_size;
-
-/// 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 += config.io_depth_read + config.io_depth_write; // Journal I/O
-    sum += config.clients_max; // Replica.client_table
-    sum += 1; // Replica.loopback_queue
-    sum += config.pipeline_max; // Replica.pipeline
-    // 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 += config.replicas_max;
-    sum += config.connections_max; // Connection.recv_message
-    sum += config.connections_max * config.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;
-    sum += 20; // TODO Our network simulator allows up to 20 messages for path_capacity_max.
-
-    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 += config.replicas_max; // Connection.recv_message
-    sum += config.replicas_max * config.connection_send_queue_max_client; // Connection.send_queue
-    sum += config.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;
-    sum += 20; // TODO Our network simulator allows up to 20 messages for path_capacity_max.
-
-    break :messages_max sum;
-};
-
-comptime {
-    // These conditions are necessary (but not sufficient) to prevent deadlocks.
-    assert(messages_max_replica > config.replicas_max);
-    assert(messages_max_client > config.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,
-        /// This buffer is aligned to config.sector_size and casting to that alignment in order
-        /// to perform Direct I/O is safe.
-        buffer: []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: *Message) []u8 {
-            return message.buffer[@sizeOf(Header)..message.header.size];
-        }
-    };
-
-    /// List of currently unused messages of message_size_max_padded
-    free_list: ?*Message,
-
-    pub fn init(allocator: mem.Allocator, process_type: vsr.ProcessType) error{OutOfMemory}!MessagePool {
-        const messages_max: usize = switch (process_type) {
-            .replica => messages_max_replica,
-            .client => messages_max_client,
-        };
-
-        var ret: MessagePool = .{
-            .free_list = null,
-        };
-        {
-            var i: usize = 0;
-            while (i < messages_max) : (i += 1) {
-                const buffer = try allocator.allocAdvanced(
-                    u8,
-                    config.sector_size,
-                    message_size_max_padded,
-                    .exact,
-                );
-                const message = try allocator.create(Message);
-                message.* = .{
-                    .header = mem.bytesAsValue(Header, buffer[0..@sizeOf(Header)]),
-                    .buffer = buffer,
-                    .next = ret.free_list,
-                };
-                ret.free_list = message;
-            }
-        }
-
-        return ret;
-    }
-
-    /// Get an unused message with a buffer of config.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) {
-            if (builtin.mode == .Debug) mem.set(u8, message.buffer, undefined);
-            message.next = pool.free_list;
-            pool.free_list = message;
-        }
-    }
-};

package/src/tigerbeetle/src/ring_buffer.zig

@@ -1,289 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-/// A First In, First Out ring buffer holding at most `count_max` elements.
-pub fn RingBuffer(comptime T: type, comptime count_max: usize) type {
-    return struct {
-        const Self = @This();
-
-        buffer: [count_max]T = undefined,
-
-        /// The index of the slot with the first item, if any.
-        index: usize = 0,
-
-        /// The number of items in the buffer.
-        count: usize = 0,
-
-        // TODO add doc comments to these functions:
-        pub inline fn head(self: Self) ?T {
-            if (self.empty()) return null;
-            return self.buffer[self.index];
-        }
-
-        pub inline fn head_ptr(self: *Self) ?*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];
-        }
-
-        pub inline fn tail_ptr(self: *Self) ?*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];
-            } else {
-                assert(index < count_max);
-                return null;
-            }
-        }
-
-        pub inline fn next_tail(self: Self) ?T {
-            if (self.full()) return null;
-            return self.buffer[(self.index + self.count) % self.buffer.len];
-        }
-
-        pub inline fn next_tail_ptr(self: *Self) ?*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;
-            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,
-            };
-        }
-
-        /// 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: *Self,
-            count: usize = 0,
-
-            pub fn next(it: *Iterator) ?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];
-            }
-
-            pub fn next_ptr(it: *Iterator) ?*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];
-            }
-        };
-
-        /// 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 {
-            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);
-}
-
-test "RingBuffer: low level interface" {
-    const Ring = RingBuffer(u32, 2);
-
-    var ring = Ring{};
-    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());
-
-    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 });
-
-    var iterator = ring.iterator();
-    while (iterator.next_ptr()) |item_ptr| {
-        item_ptr.* += 1000;
-    }
-
-    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});
-
-    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 testing.expectEqual(@as(?u32, 1002), ring.head());
-    try testing.expectEqual(@as(u32, 1002), 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: push/pop high level interface" {
-    var fifo = RingBuffer(u32, 3){};
-
-    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){};
-    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());
-}