tigerbeetle 0.0.34 → 0.0.37

data/ext/tb_client/tigerbeetle/src/io.zig

@@ -0,0 +1,34 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const os = std.os;
+
+const IO_Linux = @import("io/linux.zig").IO;
+const IO_Darwin = @import("io/darwin.zig").IO;
+const IO_Windows = @import("io/windows.zig").IO;
+
+pub const IO = switch (builtin.target.os.tag) {
+    .linux => IO_Linux,
+    .windows => IO_Windows,
+    .macos, .tvos, .watchos, .ios => IO_Darwin,
+    else => @compileError("IO is not supported for platform"),
+};
+
+pub const DirectIO = enum {
+    direct_io_required,
+    direct_io_optional,
+    direct_io_disabled,
+};
+
+pub fn buffer_limit(buffer_len: usize) usize {
+    // Linux limits how much may be written in a `pwrite()/pread()` call, which is `0x7ffff000` on
+    // both 64-bit and 32-bit systems, due to using a signed C int as the return value, as well as
+    // stuffing the errno codes into the last `4096` values.
+    // Darwin limits writes to `0x7fffffff` bytes, more than that returns `EINVAL`.
+    // The corresponding POSIX limit is `std.math.maxInt(isize)`.
+    const limit = switch (builtin.target.os.tag) {
+        .linux => 0x7ffff000,
+        .macos, .ios, .watchos, .tvos => std.math.maxInt(i32),
+        else => std.math.maxInt(isize),
+    };
+    return @min(limit, buffer_len);
+}

data/ext/tb_client/tigerbeetle/src/iops.zig

@@ -0,0 +1,134 @@
+const std = @import("std");
+const stdx = @import("stdx");
+const assert = std.debug.assert;
+
+/// Take a u8 to limit to 255 items max (maxInt(u8) == 255).
+pub fn IOPSType(comptime T: type, comptime size: u8) type {
+    const Map = stdx.BitSetType(size);
+
+    return struct {
+        const IOPS = @This();
+
+        items: [size]T = undefined,
+        busy: Map = .{},
+
+        pub fn acquire(self: *IOPS) ?*T {
+            const i = self.busy.first_unset() orelse return null;
+            self.busy.set(i);
+            return &self.items[i];
+        }
+
+        pub fn release(self: *IOPS, item: *T) void {
+            item.* = undefined;
+            const i = self.index(item);
+            assert(self.busy.is_set(i));
+            self.busy.unset(i);
+        }
+
+        pub fn index(self: *IOPS, item: *T) usize {
+            const i = @divExact(
+                (@intFromPtr(item) - @intFromPtr(&self.items)),
+                @sizeOf(T),
+            );
+            assert(i < size);
+            return i;
+        }
+
+        /// Returns the count of IOPs available.
+        pub fn available(self: *const IOPS) usize {
+            return self.busy.capacity() - self.busy.count();
+        }
+
+        pub inline fn total(_: *const IOPS) usize {
+            return size;
+        }
+
+        /// Returns the count of IOPs in use.
+        pub fn executing(self: *const IOPS) usize {
+            return self.busy.count();
+        }
+
+        pub const Iterator = struct {
+            iops: *IOPS,
+            bitset_iterator: Map.Iterator,
+
+            pub fn next(iterator: *@This()) ?*T {
+                const i = iterator.bitset_iterator.next() orelse return null;
+                return &iterator.iops.items[i];
+            }
+        };
+
+        pub const IteratorConst = struct {
+            iops: *const IOPS,
+            bitset_iterator: Map.Iterator,
+
+            pub fn next(iterator: *@This()) ?*const T {
+                const i = iterator.bitset_iterator.next() orelse return null;
+                return &iterator.iops.items[i];
+            }
+        };
+
+        /// Iterates over all currently executing IOPs.
+        pub fn iterate(self: *IOPS) Iterator {
+            return .{
+                .iops = self,
+                .bitset_iterator = self.busy.iterate(),
+            };
+        }
+
+        /// Iterates over all currently executing IOPs.
+        pub fn iterate_const(self: *const IOPS) IteratorConst {
+            return .{
+                .iops = self,
+                .bitset_iterator = self.busy.iterate(),
+            };
+        }
+    };
+}
+
+test "IOPS" {
+    const testing = std.testing;
+    var iops = IOPSType(u32, 4){};
+
+    try testing.expectEqual(@as(usize, 4), iops.available());
+    try testing.expectEqual(@as(usize, 0), iops.executing());
+
+    var one = iops.acquire().?;
+
+    try testing.expectEqual(@as(usize, 3), iops.available());
+    try testing.expectEqual(@as(usize, 1), iops.executing());
+
+    var two = iops.acquire().?;
+    var three = iops.acquire().?;
+
+    try testing.expectEqual(@as(usize, 1), iops.available());
+    try testing.expectEqual(@as(usize, 3), iops.executing());
+
+    var four = iops.acquire().?;
+    try testing.expectEqual(@as(?*u32, null), iops.acquire());
+
+    try testing.expectEqual(@as(usize, 0), iops.available());
+    try testing.expectEqual(@as(usize, 4), iops.executing());
+
+    iops.release(two);
+
+    try testing.expectEqual(@as(usize, 1), iops.available());
+    try testing.expectEqual(@as(usize, 3), iops.executing());
+
+    // there is only one slot free, so we will get the same pointer back.
+    try testing.expectEqual(@as(?*u32, two), iops.acquire());
+
+    iops.release(four);
+    iops.release(two);
+    iops.release(one);
+    iops.release(three);
+
+    try testing.expectEqual(@as(usize, 4), iops.available());
+    try testing.expectEqual(@as(usize, 0), iops.executing());
+
+    one = iops.acquire().?;
+    two = iops.acquire().?;
+    three = iops.acquire().?;
+    four = iops.acquire().?;
+    try testing.expectEqual(@as(?*u32, null), iops.acquire());
+}

data/ext/tb_client/tigerbeetle/src/list.zig

@@ -0,0 +1,236 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+const constants = @import("constants.zig");
+const stdx = @import("stdx");
+
+/// An intrusive doubly-linked list.
+/// Currently it is LIFO for simplicity because its consumer (IO.awaiting) doesn't care about order.
+pub fn DoublyLinkedListType(
+    comptime Node: type,
+    comptime field_back_enum: std.meta.FieldEnum(Node),
+    comptime field_next_enum: std.meta.FieldEnum(Node),
+) type {
+    assert(@typeInfo(Node) == .@"struct");
+    assert(field_back_enum != field_next_enum);
+
+    const field_back = @tagName(field_back_enum);
+    const field_next = @tagName(field_next_enum);
+    assert(@FieldType(Node, field_back) == ?*Node);
+    assert(@FieldType(Node, field_next) == ?*Node);
+
+    return struct {
+        const DoublyLinkedList = @This();
+
+        tail: ?*Node = null,
+        count: u32 = 0,
+
+        pub fn verify(list: *const DoublyLinkedList) void {
+            assert((list.count == 0) == (list.tail == null));
+
+            var count: u32 = 0;
+            var iterator = list.tail;
+
+            if (iterator) |node| {
+                assert(@field(node, field_next) == null);
+            }
+
+            while (iterator) |node| {
+                const back = @field(node, field_back);
+                if (back) |back_node| {
+                    assert(back_node != node); // There are no cycles.
+                    assert(@field(back_node, field_next) == node);
+                }
+                count += 1;
+                iterator = back;
+            }
+            assert(count == list.count);
+        }
+
+        fn contains(list: *const DoublyLinkedList, target: *const Node) bool {
+            var count: u32 = 0;
+
+            var iterator = list.tail;
+            while (iterator) |node| {
+                if (node == target) return true;
+                iterator = @field(node, field_back);
+                count += 1;
+            }
+
+            assert(count == list.count);
+            return false;
+        }
+
+        pub fn empty(list: *const DoublyLinkedList) bool {
+            assert((list.count == 0) == (list.tail == null));
+            return list.count == 0;
+        }
+
+        pub fn push(list: *DoublyLinkedList, node: *Node) void {
+            if (constants.verify) assert(!list.contains(node));
+            if (constants.verify) list.verify();
+            assert(@field(node, field_back) == null);
+            assert(@field(node, field_next) == null);
+
+            if (list.tail) |tail| {
+                assert(list.count > 0);
+                assert(@field(tail, field_next) == null);
+
+                @field(node, field_back) = tail;
+                @field(tail, field_next) = node;
+            } else {
+                assert(list.count == 0);
+            }
+
+            list.tail = node;
+            list.count += 1;
+        }
+
+        pub fn pop(list: *DoublyLinkedList) ?*Node {
+            if (constants.verify) list.verify();
+
+            if (list.tail) |tail_old| {
+                assert(list.count > 0);
+                assert(@field(tail_old, field_next) == null);
+
+                list.tail = @field(tail_old, field_back);
+                list.count -= 1;
+
+                if (list.tail) |tail_new| {
+                    assert(@field(tail_new, field_next) == tail_old);
+                    @field(tail_new, field_next) = null;
+                }
+
+                @field(tail_old, field_back) = null;
+                return tail_old;
+            } else {
+                assert(list.count == 0);
+                return null;
+            }
+        }
+
+        pub fn remove(list: *DoublyLinkedList, node: *Node) void {
+            if (constants.verify) assert(list.contains(node));
+            if (constants.verify) list.verify();
+            assert(list.count > 0);
+            assert(list.tail != null);
+
+            const tail = list.tail.?;
+
+            if (node == tail) {
+                // Pop the last element of the list.
+                assert(@field(node, field_next) == null);
+                list.tail = @field(node, field_back);
+            }
+            if (@field(node, field_back)) |node_back| {
+                assert(@field(node_back, field_next).? == node);
+                @field(node_back, field_next) = @field(node, field_next);
+            }
+            if (@field(node, field_next)) |node_next| {
+                assert(@field(node_next, field_back).? == node);
+                @field(node_next, field_back) = @field(node, field_back);
+            }
+            @field(node, field_back) = null;
+            @field(node, field_next) = null;
+            list.count -= 1;
+
+            if (constants.verify) list.verify();
+            assert((list.count == 0) == (list.tail == null));
+        }
+    };
+}
+
+test "DoublyLinkedList LIFO" {
+    const Node = struct { id: u32, back: ?*@This() = null, next: ?*@This() = null };
+    const List = DoublyLinkedListType(Node, .back, .next);
+
+    var nodes: [3]Node = undefined;
+    for (&nodes, 0..) |*node, i| node.* = .{ .id = @intCast(i) };
+
+    var list = List{};
+    list.push(&nodes[0]);
+    list.push(&nodes[1]);
+    list.push(&nodes[2]);
+
+    try std.testing.expectEqual(list.pop().?, &nodes[2]);
+    try std.testing.expectEqual(list.pop().?, &nodes[1]);
+    try std.testing.expectEqual(list.pop().?, &nodes[0]);
+    try std.testing.expectEqual(list.pop(), null);
+}
+
+test "DoublyLinkedList fuzz" {
+    // Ensure that The DoublyLinkedList's extra-verification is enabled.
+    comptime assert(constants.verify);
+
+    const allocator = std.testing.allocator;
+
+    var prng = stdx.PRNG.from_seed_testing();
+
+    const Node = struct { id: u32, back: ?*@This() = null, next: ?*@This() = null };
+    const List = DoublyLinkedListType(Node, .back, .next);
+
+    const nodes_count = 1024;
+    const events_max = 1 << 15;
+
+    const Event = enum { push, pop, remove };
+    const event_weights: stdx.PRNG.EnumWeightsType(Event) = .{ .push = 10, .pop = 1, .remove = 8 };
+
+    const nodes = try allocator.alloc(Node, nodes_count);
+    defer allocator.free(nodes);
+
+    for (nodes, 0..) |*node, i| node.* = .{ .id = @intCast(i) };
+
+    var nodes_free = try std.DynamicBitSetUnmanaged.initFull(allocator, nodes_count);
+    defer nodes_free.deinit(allocator);
+
+    var list = List{};
+    var list_model = stdx.BoundedArrayType(u32, nodes_count){};
+
+    for (0..events_max) |_| {
+        assert(list_model.count() <= nodes_count);
+        assert(list_model.count() == list.count);
+        assert(list_model.empty() == list.empty());
+
+        const event = prng.enum_weighted(Event, event_weights);
+        switch (event) {
+            .push => {
+                const node_free = nodes_free.findFirstSet() orelse continue;
+                const node = &nodes[node_free];
+
+                list.push(node);
+                list_model.push(node.id);
+                nodes_free.unset(node.id);
+            },
+            .pop => {
+                if (list.pop()) |node| {
+                    assert(node.back == null);
+                    assert(node.next == null);
+
+                    const node_id = list_model.pop().?;
+                    assert(node_id == node.id);
+                    assert(nodes_free.count() < nodes_count);
+                    assert(!nodes_free.isSet(node_id));
+
+                    nodes_free.set(node_id);
+                } else {
+                    assert(nodes_free.count() == nodes_count);
+                    assert(list_model.empty());
+                }
+            },
+            .remove => {
+                if (list_model.count() == 0) continue;
+
+                const list_index = prng.index(list_model.slice());
+                const node_id = list_model.get(list_index);
+                assert(node_id == list_model.ordered_remove(list_index));
+                assert(!nodes_free.isSet(node_id));
+
+                list.remove(&nodes[node_id]);
+                assert(nodes[node_id].back == null);
+                assert(nodes[node_id].next == null);
+
+                nodes_free.set(node_id);
+            },
+        }
+    }
+}