tigerbeetle 0.0.36 → 0.0.38

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

@@ -0,0 +1,82 @@
+//! An allocator wrapper which can be disabled at runtime.
+//! We use this for allocating at startup and then
+//! disable it to prevent accidental dynamic allocation at runtime.
+
+const std = @import("std");
+const assert = std.debug.assert;
+const mem = std.mem;
+const Alignment = mem.Alignment;
+
+const StaticAllocator = @This();
+parent_allocator: mem.Allocator,
+state: State,
+
+const State = enum {
+    /// Allow `alloc` and `resize`.
+    /// (To make errdefer cleanup easier to write we also allow calling `free`,
+    ///  in which case we switch state to `.deinit` and no longer allow `alloc` or `resize`.)
+    init,
+    /// Don't allow any calls.
+    static,
+    /// Allow `free` but not `alloc` and `resize`.
+    deinit,
+};
+
+pub fn init(parent_allocator: mem.Allocator) StaticAllocator {
+    return .{
+        .parent_allocator = parent_allocator,
+        .state = .init,
+    };
+}
+
+pub fn deinit(self: *StaticAllocator) void {
+    self.* = undefined;
+}
+
+pub fn transition_from_init_to_static(self: *StaticAllocator) void {
+    assert(self.state == .init);
+    self.state = .static;
+}
+
+pub fn transition_from_static_to_deinit(self: *StaticAllocator) void {
+    assert(self.state == .static);
+    self.state = .deinit;
+}
+
+pub fn allocator(self: *StaticAllocator) mem.Allocator {
+    return .{
+        .ptr = self,
+        .vtable = &.{
+            .alloc = alloc,
+            .resize = resize,
+            .remap = remap,
+            .free = free,
+        },
+    };
+}
+
+fn alloc(ctx: *anyopaque, len: usize, ptr_align: Alignment, ret_addr: usize) ?[*]u8 {
+    const self: *StaticAllocator = @ptrCast(@alignCast(ctx));
+    assert(self.state == .init);
+    return self.parent_allocator.rawAlloc(len, ptr_align, ret_addr);
+}
+
+fn resize(ctx: *anyopaque, buf: []u8, buf_align: Alignment, new_len: usize, ret_addr: usize) bool {
+    const self: *StaticAllocator = @ptrCast(@alignCast(ctx));
+    assert(self.state == .init);
+    return self.parent_allocator.rawResize(buf, buf_align, new_len, ret_addr);
+}
+
+fn remap(ctx: *anyopaque, buf: []u8, buf_align: Alignment, new_len: usize, ret_addr: usize) ?[*]u8 {
+    const self: *StaticAllocator = @ptrCast(@alignCast(ctx));
+    assert(self.state == .init);
+    return self.parent_allocator.rawRemap(buf, buf_align, new_len, ret_addr);
+}
+
+fn free(ctx: *anyopaque, buf: []u8, buf_align: Alignment, ret_addr: usize) void {
+    const self: *StaticAllocator = @ptrCast(@alignCast(ctx));
+    assert(self.state == .init or self.state == .deinit);
+    // Once you start freeing, you don't stop.
+    self.state = .deinit;
+    return self.parent_allocator.rawFree(buf, buf_align, ret_addr);
+}

data/ext/tb_client/tigerbeetle/src/stdx/bit_set.zig

@@ -0,0 +1,157 @@
+const stdx = @import("stdx.zig");
+const std = @import("std");
+const assert = std.debug.assert;
+
+/// Use a dynamic bitset for larger sizes.
+pub fn BitSetType(comptime with_capacity: u9) type {
+    assert(with_capacity <= 256);
+
+    return struct {
+        // While mathematically 0 and 1 are symmetric, we intentionally bias the API to use zeros
+        // default, as zero-initialization reduces binary size.
+        bits: Word = 0,
+
+        pub const Word = for (.{ u8, u16, u32, u64, u128, u256 }) |w| {
+            if (@bitSizeOf(w) >= with_capacity) break w;
+        } else unreachable;
+
+        const BitSet = @This();
+
+        pub fn is_set(bit_set: BitSet, index: usize) bool {
+            assert(index < bit_set.capacity());
+            return bit_set.bits & bit(index) != 0;
+        }
+
+        pub fn count(bit_set: BitSet) usize {
+            return @popCount(bit_set.bits);
+        }
+
+        pub inline fn capacity(_: BitSet) usize {
+            return with_capacity;
+        }
+
+        pub fn full(bit_set: BitSet) bool {
+            return bit_set.count() == bit_set.capacity();
+        }
+
+        pub fn empty(bit_set: BitSet) bool {
+            return bit_set.bits == 0;
+        }
+
+        pub fn first_set(bit_set: BitSet) ?usize {
+            if (bit_set.bits == 0) return null;
+            return @ctz(bit_set.bits);
+        }
+
+        pub fn first_unset(bit_set: BitSet) ?usize {
+            const result = @ctz(~bit_set.bits);
+            return if (result < bit_set.capacity()) result else null;
+        }
+
+        pub fn set(bit_set: *BitSet, index: usize) void {
+            assert(index < bit_set.capacity());
+            bit_set.bits |= bit(index);
+        }
+
+        pub fn unset(bit_set: *BitSet, index: usize) void {
+            assert(index < bit_set.capacity());
+            bit_set.bits &= ~bit(index);
+        }
+
+        pub fn set_value(bit_set: *BitSet, index: usize, value: bool) void {
+            if (value) {
+                bit_set.set(index);
+            } else {
+                bit_set.unset(index);
+            }
+        }
+
+        fn bit(index: usize) Word {
+            assert(index < with_capacity);
+            return @as(Word, 1) << @intCast(index);
+        }
+
+        pub fn iterate(bit_set: BitSet) Iterator {
+            return .{ .bits_remain = bit_set.bits };
+        }
+
+        pub const Iterator = struct {
+            bits_remain: Word,
+
+            pub fn next(it: *@This()) ?usize {
+                const result = @ctz(it.bits_remain);
+                if (result >= with_capacity) return null;
+                it.bits_remain &= it.bits_remain - 1;
+                return result;
+            }
+        };
+    };
+}
+
+test BitSetType {
+    var prng = stdx.PRNG.from_seed_testing();
+    inline for (.{ 0, 1, 8, 32, 65, 255, 256 }) |N| {
+        const BitSet = BitSetType(N);
+
+        var set: BitSet = .{};
+        var model = try std.DynamicBitSetUnmanaged.initEmpty(std.testing.allocator, N);
+        defer model.deinit(std.testing.allocator);
+
+        for (0..1000) |_| {
+            switch (prng.enum_uniform(std.meta.DeclEnum(BitSet))) {
+                .Word => {
+                    const bit_size =
+                        comptime if (N == 0) 8 else @max(8, try std.math.ceilPowerOfTwo(u16, N));
+                    assert(BitSet.Word == std.meta.Int(.unsigned, bit_size));
+                },
+                .Iterator => {},
+                .is_set => {
+                    if (N > 0) {
+                        const bit = prng.int_inclusive(usize, N - 1);
+                        assert(set.is_set(bit) == model.isSet(bit));
+                    }
+                },
+                .count => assert(set.count() == model.count()),
+                .capacity => assert(set.capacity() == N),
+                .full => assert(set.full() == (model.count() == N)),
+                .empty => assert(set.empty() == (model.count() == 0)),
+                .first_set => assert(set.first_set() == model.findFirstSet()),
+                .first_unset => {
+                    var it = model.iterator(.{ .kind = .unset });
+                    assert(set.first_unset() == it.next());
+                },
+                .set => {
+                    if (N > 0) {
+                        const bit = prng.int_inclusive(usize, N - 1);
+                        set.set(bit);
+                        model.set(bit);
+                    }
+                },
+                .unset => {
+                    if (N > 0) {
+                        const bit = prng.int_inclusive(usize, N - 1);
+                        set.unset(bit);
+                        model.unset(bit);
+                    }
+                },
+                .set_value => {
+                    if (N > 0) {
+                        const bit = prng.int_inclusive(usize, N - 1);
+                        const value = prng.boolean();
+                        set.set_value(bit, value);
+                        model.setValue(bit, value);
+                    }
+                },
+                .iterate => {
+                    var it_set = set.iterate();
+                    var it_model = model.iterator(.{});
+                    while (it_model.next()) |next| {
+                        assert(next == it_set.next());
+                    }
+                    assert(it_set.next() == null);
+                    assert(it_set.next() == null);
+                },
+            }
+        }
+    }
+}

data/ext/tb_client/tigerbeetle/src/stdx/bounded_array.zig

@@ -0,0 +1,292 @@
+const std = @import("std");
+const stdx = @import("stdx.zig");
+const assert = std.debug.assert;
+
+/// A version of standard `BoundedArray` with TigerBeetle-idiomatic APIs.
+pub fn BoundedArrayType(comptime T: type, comptime buffer_capacity: usize) type {
+    return struct {
+        buffer: [buffer_capacity]T = undefined,
+        // Its not clear whether the best type of count is u32, usize, or u`log(buffer_capacity)`.
+        // Use an ugly internal name here and expose `pub fn count` as an API.
+        count_u32: u32 = 0,
+
+        const BoundedArray = @This();
+
+        pub inline fn from_slice(items: []const T) error{Overflow}!BoundedArray {
+            if (items.len <= buffer_capacity) {
+                var result: BoundedArray = .{};
+                result.push_slice(items);
+                return result;
+            } else {
+                return error.Overflow;
+            }
+        }
+
+        pub inline fn count(array: *const BoundedArray) usize {
+            return array.count_u32;
+        }
+
+        /// Returns count of elements in this BoundedArray in the specified integer types,
+        /// checking at compile time that it indeed can represent the length.
+        pub inline fn count_as(array: *const BoundedArray, comptime Int: type) Int {
+            comptime assert(buffer_capacity <= std.math.maxInt(Int));
+            return @intCast(array.count_u32);
+        }
+
+        pub inline fn full(array: BoundedArray) bool {
+            return array.count_u32 == buffer_capacity;
+        }
+
+        pub inline fn empty(array: BoundedArray) bool {
+            return array.count_u32 == 0;
+        }
+
+        pub inline fn get(array: *const BoundedArray, index: usize) T {
+            assert(index < array.count_u32);
+            return array.buffer[index];
+        }
+
+        pub inline fn slice(array: *BoundedArray) []T {
+            return array.buffer[0..array.count_u32];
+        }
+
+        pub inline fn const_slice(array: *const BoundedArray) []const T {
+            return array.buffer[0..array.count_u32];
+        }
+
+        pub inline fn unused_capacity_slice(array: *BoundedArray) []T {
+            return array.buffer[array.count_u32..];
+        }
+
+        pub fn insert_at(array: *BoundedArray, index: usize, item: T) void {
+            assert(!array.full());
+            assert(index <= array.count_u32);
+            stdx.copy_right(
+                .exact,
+                T,
+                array.buffer[index + 1 .. array.count_u32 + 1],
+                array.buffer[index..array.count_u32],
+            );
+            array.buffer[index] = item;
+            array.count_u32 += 1;
+        }
+
+        pub fn push(array: *BoundedArray, item: T) void {
+            assert(!array.full());
+            array.buffer[array.count_u32] = item;
+            array.count_u32 += 1;
+        }
+
+        pub fn push_slice(array: *BoundedArray, items: []const T) void {
+            assert(array.count_u32 + items.len <= array.capacity());
+            stdx.copy_disjoint(.inexact, T, array.buffer[array.count_u32..], items);
+            array.count_u32 += @intCast(items.len);
+        }
+
+        pub inline fn swap_remove(array: *BoundedArray, index: usize) T {
+            assert(array.count_u32 > 0);
+            assert(index < array.count_u32);
+            const result = array.buffer[index];
+            array.count_u32 -= 1;
+            array.buffer[index] = array.buffer[array.count_u32];
+            return result;
+        }
+
+        pub inline fn ordered_remove(array: *BoundedArray, index: usize) T {
+            assert(array.count_u32 > 0);
+            assert(index < array.count_u32);
+            const result = array.buffer[index];
+            stdx.copy_left(
+                .exact,
+                T,
+                array.buffer[index .. array.count_u32 - 1],
+                array.buffer[index + 1 .. array.count_u32],
+            );
+            array.count_u32 -= 1;
+            return result;
+        }
+
+        pub fn resize(array: *BoundedArray, count_new: usize) error{Overflow}!void {
+            if (count_new <= buffer_capacity) {
+                array.count_u32 = @intCast(count_new);
+            } else {
+                return error.Overflow;
+            }
+        }
+
+        pub inline fn truncate(array: *BoundedArray, count_new: usize) void {
+            assert(count_new <= array.count_u32);
+            array.count_u32 = @intCast(count_new); // can't overflow due to check above.
+        }
+
+        pub inline fn clear(array: *BoundedArray) void {
+            array.count_u32 = 0;
+        }
+
+        pub inline fn pop(array: *BoundedArray) ?T {
+            if (array.count_u32 == 0) return null;
+            array.count_u32 -= 1;
+            return array.buffer[array.count_u32];
+        }
+
+        pub inline fn capacity(_: *BoundedArray) usize {
+            return buffer_capacity;
+        }
+    };
+}
+
+test BoundedArrayType {
+    const capacity = 8;
+    const Array = BoundedArrayType(u8, capacity);
+    const Model = std.ArrayListUnmanaged(u8);
+    const swarm_count = 10;
+    const action_count = 1_000;
+
+    const gpa = std.testing.allocator;
+
+    var array: Array = .{};
+    var model: Model = try .initCapacity(gpa, capacity);
+    defer model.deinit(gpa);
+
+    var prng = stdx.PRNG.from_seed_testing();
+
+    for (0..swarm_count) |_| {
+        const swarm_weights = prng.enum_weights(std.meta.DeclEnum(Array));
+        for (0..action_count) |_| {
+            const action = prng.enum_weighted(std.meta.DeclEnum(Array), swarm_weights);
+            switch (action) {
+                .count => assert(array.count() == model.items.len),
+                .count_as => assert(array.count_as(u8) == model.items.len),
+                .full => assert(array.full() == (model.unusedCapacitySlice().len == 0)),
+                .empty => assert(array.empty() == (model.items.len == 0)),
+                .get => {
+                    if (model.items.len > 0) {
+                        const index = prng.index(model.items);
+                        assert(array.get(index) == model.items[index]);
+                    }
+                },
+                .slice => assert(std.mem.eql(u8, array.slice(), model.items)),
+                .const_slice => assert(std.mem.eql(u8, array.const_slice(), model.items)),
+                .unused_capacity_slice => {
+                    assert(array.unused_capacity_slice().len == model.unusedCapacitySlice().len);
+                },
+                .insert_at => {
+                    if (model.items.len < model.capacity) {
+                        const index = prng.int_inclusive(usize, model.items.len);
+                        const value = prng.int(u8);
+
+                        array.insert_at(index, value);
+                        model.insertAssumeCapacity(index, value);
+                    }
+                },
+                .push => {
+                    if (model.items.len < model.capacity) {
+                        const value = prng.int(u8);
+
+                        array.push(value);
+                        model.appendAssumeCapacity(value);
+                    }
+                },
+                .push_slice => {
+                    var buffer: [capacity]u8 = undefined;
+                    const count = prng.int_inclusive(usize, model.capacity - model.items.len);
+                    for (0..count) |index| buffer[index] = prng.int(u8);
+                    const slice = buffer[0..count];
+
+                    array.push_slice(slice);
+                    model.appendSliceAssumeCapacity(slice);
+                },
+                .swap_remove => {
+                    if (model.items.len > 0) {
+                        const index = prng.index(model.items);
+
+                        const a = array.swap_remove(index);
+                        const b = model.swapRemove(index);
+                        assert(a == b);
+                    }
+                },
+                .ordered_remove => {
+                    if (model.items.len > 0) {
+                        const index = prng.index(model.items);
+
+                        const a = array.ordered_remove(index);
+                        const b = model.orderedRemove(index);
+                        assert(a == b);
+                    }
+                },
+                .resize => {
+                    const count_old = model.items.len;
+                    const count_new = prng.int_inclusive(usize, capacity);
+
+                    model.resize(gpa, count_new) catch unreachable;
+                    array.resize(count_new) catch unreachable;
+                    if (count_old <= count_new) {
+                        for (count_old..count_new) |index| {
+                            const value = prng.int(u8);
+                            model.items[index] = value;
+                            array.buffer[index] = value;
+                        }
+                    }
+                },
+                .truncate => {
+                    const count_new = prng.int_inclusive(usize, model.items.len);
+                    array.truncate(count_new);
+                    model.resize(gpa, count_new) catch unreachable;
+                },
+                .clear => {
+                    array.clear();
+                    model.clearRetainingCapacity();
+                },
+                .pop => {
+                    const b = model.pop();
+                    const a = array.pop();
+                    assert((a == null and b == null) or (a.? == b.?));
+                },
+                .capacity => assert(array.capacity() == model.capacity),
+                .from_slice => {
+                    var buffer: [capacity]u8 = undefined;
+                    const count = prng.int_inclusive(usize, model.capacity - model.items.len);
+                    for (0..count) |index| buffer[index] = prng.int(u8);
+                    const slice = buffer[0..count];
+
+                    array = Array.from_slice(slice) catch unreachable;
+                    model.clearRetainingCapacity();
+                    model.appendSliceAssumeCapacity(slice);
+                },
+            }
+        }
+    }
+}
+
+test "BoundedArray.insert_at" {
+    const items_max = 32;
+    const BoundedArrayU64 = BoundedArrayType(u64, items_max);
+
+    // Test lists of every size (less than the capacity).
+    for (0..items_max) |len| {
+        var list_base = BoundedArrayU64{};
+        for (0..len) |i| {
+            list_base.push(i);
+        }
+
+        // Test an insert at every possible position (including an append).
+        for (0..list_base.count() + 1) |i| {
+            var list = list_base;
+
+            list.insert_at(i, 12345);
+
+            // Verify the result:
+
+            try std.testing.expectEqual(list.count(), list_base.count() + 1);
+            try std.testing.expectEqual(list.get(i), 12345);
+
+            for (0..i) |j| {
+                try std.testing.expectEqual(list.get(j), j);
+            }
+
+            for (i + 1..list.count()) |j| {
+                try std.testing.expectEqual(list.get(j), j - 1);
+            }
+        }
+    }
+}

data/ext/tb_client/tigerbeetle/src/stdx/debug.zig

@@ -0,0 +1,65 @@
+const std = @import("std");
+
+/// Utility function for ad-hoc profiling.
+///
+/// A thin wrapper around `std.time.Timer` which handles the boilerplate of
+/// printing to stderr and formatting times in some (unspecified) readable way.
+pub fn timeit() TimeIt {
+    return TimeIt{ .inner = std.time.Timer.start() catch unreachable };
+}
+
+const TimeIt = struct {
+    inner: std.time.Timer,
+
+    /// Prints elapsed time to stderr and resets the internal timer.
+    pub fn print(self: *TimeIt, comptime label: []const u8) void {
+        const label_alignment = comptime " " ** (1 + (12 -| label.len));
+
+        const elapsed_ns = self.inner.lap();
+        std.debug.print(
+            label ++ ":" ++ label_alignment ++ "{}\n",
+            .{std.fmt.fmtDuration(elapsed_ns)},
+        );
+    }
+
+    pub fn print_if_longer_than_ms(
+        self: *TimeIt,
+        threshold_ms: u64,
+        comptime label: []const u8,
+    ) void {
+        self.if_longer_than(label, threshold_ms, false);
+    }
+
+    pub fn backtrace_if_longer_than_ms(
+        self: *TimeIt,
+        threshold_ms: u64,
+        comptime label: []const u8,
+    ) void {
+        self.if_longer_than(label, threshold_ms, true);
+    }
+
+    fn if_longer_than(
+        self: *TimeIt,
+        comptime label: []const u8,
+        threshold_ms: u64,
+        backtrace: bool,
+    ) void {
+        const elapsed_ns = self.inner.lap();
+        if (elapsed_ns > threshold_ms * std.time.ns_per_ms) {
+            std.debug.print(label ++ ": {}\n", .{std.fmt.fmtDuration(elapsed_ns)});
+            if (backtrace) std.debug.dumpCurrentStackTrace(null);
+        }
+    }
+};
+
+/// Utility for print-if debugging, a-la Rust's dbg! macro.
+///
+/// dbg prints the value with the prefix, while also returning the value, which makes it convenient
+/// to drop it in the middle of a complex expression.
+pub fn dbg(prefix: []const u8, value: anytype) @TypeOf(value) {
+    std.debug.print("{s} = {any}\n", .{
+        prefix,
+        std.json.fmt(value, .{ .whitespace = .indent_2 }),
+    });
+    return value;
+}