tigerbeetle-node 0.11.13 → 0.12.1

package/src/tigerbeetle/src/testing/reply_sequence.zig

@@ -1,139 +0,0 @@
-//! Replies from the cluster may arrive out-of-order; the ReplySequence reassembles them in the
-//! correct order (by ascending op number).
-const std = @import("std");
-const assert = std.debug.assert;
-
-const vsr = @import("../vsr.zig");
-const stdx = @import("../stdx.zig");
-const constants = @import("../constants.zig");
-const IdPermutation = @import("id.zig").IdPermutation;
-const MessagePool = @import("../message_pool.zig").MessagePool;
-const Message = MessagePool.Message;
-const Client = @import("cluster.zig").Client;
-const StateMachine = @import("cluster.zig").StateMachine;
-
-// TODO(zig) This won't be necessary in Zig 0.10.
-const PriorityQueue = @import("./priority_queue.zig").PriorityQueue;
-
-/// Both messages belong to the ReplySequence's `MessagePool`.
-const PendingReply = struct {
-    client_index: usize,
-    request: *Message,
-    reply: *Message,
-
-    /// `PendingReply`s are ordered by ascending reply op.
-    fn compare(context: void, a: PendingReply, b: PendingReply) std.math.Order {
-        _ = context;
-        return std.math.order(a.reply.header.op, b.reply.header.op);
-    }
-};
-
-const PendingReplyQueue = PriorityQueue(PendingReply, void, PendingReply.compare);
-
-pub const ReplySequence = struct {
-    /// Reply messages (from cluster to client) may be reordered during transit.
-    /// The ReplySequence must reassemble them in the original order (ascending op/commit
-    /// number) before handing them off to the Workload for verification.
-    ///
-    /// `ReplySequence.stalled_queue` hold replies (and corresponding requests) that are
-    /// waiting to be processed.
-    pub const stalled_queue_capacity =
-        constants.clients_max * constants.client_request_queue_max * 2;
-
-    message_pool: MessagePool,
-
-    /// The next op to be verified.
-    /// Starts at 1, because op=0 is the root.
-    stalled_op: u64 = 1,
-
-    /// The list of messages waiting to be verified (the reply for a lower op has not yet arrived).
-    /// Includes `register` messages.
-    stalled_queue: PendingReplyQueue,
-
-    pub fn init(allocator: std.mem.Allocator) !ReplySequence {
-        // *2 for PendingReply.request and PendingReply.reply.
-        var message_pool = try MessagePool.init_capacity(allocator, stalled_queue_capacity * 2);
-        errdefer message_pool.deinit(allocator);
-
-        var stalled_queue = PendingReplyQueue.init(allocator, {});
-        errdefer stalled_queue.deinit();
-        try stalled_queue.ensureTotalCapacity(stalled_queue_capacity);
-
-        return ReplySequence{
-            .message_pool = message_pool,
-            .stalled_queue = stalled_queue,
-        };
-    }
-
-    pub fn deinit(sequence: *ReplySequence, allocator: std.mem.Allocator) void {
-        while (sequence.stalled_queue.removeOrNull()) |pending| {
-            sequence.message_pool.unref(pending.request);
-            sequence.message_pool.unref(pending.reply);
-        }
-        sequence.stalled_queue.deinit();
-        sequence.message_pool.deinit(allocator);
-    }
-
-    pub fn empty(sequence: *const ReplySequence) bool {
-        return sequence.stalled_queue.len == 0;
-    }
-
-    pub fn free(sequence: ReplySequence) usize {
-        return stalled_queue_capacity - sequence.stalled_queue.len;
-    }
-
-    pub fn insert(
-        sequence: *ReplySequence,
-        client_index: usize,
-        request_message: *Message,
-        reply_message: *Message,
-    ) void {
-        assert(request_message.header.invalid() == null);
-        assert(request_message.header.command == .request);
-
-        assert(reply_message.header.invalid() == null);
-        assert(reply_message.header.request == request_message.header.request);
-        assert(reply_message.header.op >= sequence.stalled_op);
-        assert(reply_message.header.command == .reply);
-        assert(reply_message.header.operation == request_message.header.operation);
-
-        sequence.stalled_queue.add(.{
-            .client_index = client_index,
-            .request = sequence.clone_message(request_message),
-            .reply = sequence.clone_message(reply_message),
-        }) catch unreachable;
-    }
-
-    pub fn peek(sequence: *ReplySequence) ?PendingReply {
-        assert(sequence.stalled_queue.len <= stalled_queue_capacity);
-
-        const commit = sequence.stalled_queue.peek() orelse return null;
-        if (commit.reply.header.op == sequence.stalled_op) {
-            return commit;
-        } else {
-            assert(commit.reply.header.op > sequence.stalled_op);
-            return null;
-        }
-    }
-
-    pub fn next(sequence: *ReplySequence) void {
-        const commit = sequence.stalled_queue.remove();
-        assert(commit.reply.header.op == sequence.stalled_op);
-
-        sequence.stalled_op += 1;
-        sequence.message_pool.unref(commit.reply);
-        sequence.message_pool.unref(commit.request);
-    }
-
-    /// Copy the message from a Client's MessagePool to the ReplySequence's MessagePool.
-    ///
-    /// The client has a finite amount of messages in its pool, and the ReplySequence needs to hold
-    /// onto requests/replies until all preceeding requests/replies have arrived.
-    ///
-    /// Returns the ReplySequence's message.
-    fn clone_message(sequence: *ReplySequence, message_client: *const Message) *Message {
-        const message_sequence = sequence.message_pool.get_message();
-        stdx.copy_disjoint(.exact, u8, message_sequence.buffer, message_client.buffer);
-        return message_sequence;
-    }
-};

package/src/tigerbeetle/src/testing/state_machine.zig

@@ -1,250 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-const constants = @import("../constants.zig");
-const vsr = @import("../vsr.zig");
-const log = std.log.scoped(.state_machine);
-
-pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
-    message_body_size_max: usize,
-    lsm_batch_multiple: usize,
-}) type {
-    _ = Storage;
-    _ = constants_;
-
-    return struct {
-        const StateMachine = @This();
-        const Grid = @import("../lsm/grid.zig").GridType(Storage);
-
-        pub const Workload = WorkloadType(StateMachine);
-
-        pub const Operation = enum(u8) {
-            /// Operations reserved by VR protocol (for all state machines):
-            reserved,
-            root,
-            register,
-
-            echo,
-        };
-
-        pub const Options = struct {};
-
-        options: Options,
-        grid: *Grid,
-        grid_block: Grid.BlockPtr,
-        grid_write: Grid.Write = undefined,
-        prepare_timestamp: u64 = 0,
-        commit_timestamp: u64 = 0,
-
-        callback: ?fn (state_machine: *StateMachine) void = null,
-
-        pub fn init(allocator: std.mem.Allocator, grid: *Grid, options: Options) !StateMachine {
-            const grid_block = try allocator.alignedAlloc(
-                u8,
-                constants.sector_size,
-                constants.block_size,
-            );
-            errdefer allocator.free(grid_block);
-            std.mem.set(u8, grid_block, 0);
-
-            return StateMachine{
-                .options = options,
-                .grid = grid,
-                .grid_block = grid_block[0..constants.block_size],
-            };
-        }
-
-        pub fn deinit(state_machine: *StateMachine, allocator: std.mem.Allocator) void {
-            allocator.free(state_machine.grid_block);
-        }
-
-        // TODO Grid.next_tick
-        pub fn open(state_machine: *StateMachine, callback: fn (*StateMachine) void) void {
-            callback(state_machine);
-        }
-
-        pub fn prepare(
-            state_machine: *StateMachine,
-            operation: Operation,
-            input: []u8,
-        ) u64 {
-            _ = operation;
-            _ = input;
-
-            return state_machine.prepare_timestamp;
-        }
-
-        pub fn prefetch(
-            state_machine: *StateMachine,
-            callback: fn (*StateMachine) void,
-            op: u64,
-            operation: Operation,
-            input: []const u8,
-        ) void {
-            _ = op;
-            _ = operation;
-            _ = input;
-
-            state_machine.next_tick(callback);
-        }
-
-        pub fn commit(
-            state_machine: *StateMachine,
-            client: u128,
-            op: u64,
-            timestamp: u64,
-            operation: Operation,
-            input: []const u8,
-            output: []u8,
-        ) usize {
-            _ = state_machine;
-            _ = client;
-            _ = timestamp;
-            _ = input;
-            _ = output;
-            assert(op != 0);
-
-            switch (operation) {
-                .reserved, .root => unreachable,
-                .register => return 0,
-                .echo => {
-                    std.mem.copy(u8, output, input);
-                    return input.len;
-                },
-            }
-        }
-
-        // TODO(Grid Recovery): Actually write blocks so that this state machine can be used
-        // to test grid recovery.
-        pub fn compact(
-            state_machine: *StateMachine,
-            callback: fn (*StateMachine) void,
-            op: u64,
-        ) void {
-            _ = op;
-            state_machine.next_tick(callback);
-        }
-
-        pub fn checkpoint(
-            state_machine: *StateMachine,
-            callback: fn (*StateMachine) void,
-        ) void {
-            state_machine.next_tick(callback);
-        }
-
-        // TODO Replace with Grid.next_tick()
-        fn next_tick(state_machine: *StateMachine, callback: fn (*StateMachine) void) void {
-            // TODO This is a hack to defer till the next tick; use Grid.next_tick instead.
-            var free_set = state_machine.grid.superblock.free_set;
-            const reservation = free_set.reserve(1).?;
-            defer free_set.forfeit(reservation);
-
-            const address = free_set.acquire(reservation).?;
-            const header = std.mem.bytesAsValue(
-                vsr.Header,
-                state_machine.grid_block[0..@sizeOf(vsr.Header)],
-            );
-            header.op = address;
-
-            assert(state_machine.callback == null);
-            state_machine.callback = callback;
-            state_machine.grid.write_block(
-                next_tick_callback,
-                &state_machine.grid_write,
-                &state_machine.grid_block,
-                address,
-            );
-        }
-
-        fn next_tick_callback(write: *Grid.Write) void {
-            const state_machine = @fieldParentPtr(StateMachine, "grid_write", write);
-            const callback = state_machine.callback.?;
-            state_machine.callback = null;
-            callback(state_machine);
-        }
-    };
-}
-
-fn WorkloadType(comptime StateMachine: type) type {
-    return struct {
-        const Workload = @This();
-
-        random: std.rand.Random,
-        requests_sent: usize = 0,
-        requests_delivered: usize = 0,
-
-        pub fn init(
-            allocator: std.mem.Allocator,
-            random: std.rand.Random,
-            options: Options,
-        ) !Workload {
-            _ = allocator;
-            _ = options;
-
-            return Workload{
-                .random = random,
-            };
-        }
-
-        pub fn deinit(workload: *Workload, allocator: std.mem.Allocator) void {
-            _ = workload;
-            _ = allocator;
-        }
-
-        pub fn done(workload: *const Workload) bool {
-            return workload.requests_sent == workload.requests_delivered;
-        }
-
-        pub fn build_request(
-            workload: *Workload,
-            client_index: usize,
-            body: []align(@alignOf(vsr.Header)) u8,
-        ) struct {
-            operation: StateMachine.Operation,
-            size: usize,
-        } {
-            _ = client_index;
-
-            workload.requests_sent += 1;
-
-            // +1 for inclusive limit.
-            const size = workload.random.uintLessThan(usize, constants.message_body_size_max + 1);
-            workload.random.bytes(body[0..size]);
-
-            return .{
-                .operation = .echo,
-                .size = size,
-            };
-        }
-
-        pub fn on_reply(
-            workload: *Workload,
-            client_index: usize,
-            operation: vsr.Operation,
-            timestamp: u64,
-            request_body: []align(@alignOf(vsr.Header)) const u8,
-            reply_body: []align(@alignOf(vsr.Header)) const u8,
-        ) void {
-            _ = workload;
-            _ = client_index;
-            _ = timestamp;
-
-            workload.requests_delivered += 1;
-            assert(workload.requests_delivered <= workload.requests_sent);
-
-            assert(operation.cast(StateMachine) == .echo);
-            assert(std.mem.eql(u8, request_body, reply_body));
-        }
-
-        pub const Options = struct {
-            pub fn generate(random: std.rand.Random, options: struct {
-                client_count: usize,
-                in_flight_max: usize,
-            }) Options {
-                _ = random;
-                _ = options;
-                return .{};
-            }
-        };
-    };
-}