tigerbeetle-node 0.11.12 → 0.12.0

package/src/tigerbeetle/src/vsr/journal_format_fuzz.zig

@@ -1,111 +0,0 @@
-//! Fuzz WAL formats using different write sizes.
-const std = @import("std");
-const assert = std.debug.assert;
-const log = std.log.scoped(.fuzz_journal_format);
-
-const constants = @import("../constants.zig");
-const stdx = @import("../stdx.zig");
-const vsr = @import("../vsr.zig");
-const journal = @import("./journal.zig");
-const fuzz = @import("../testing/fuzz.zig");
-
-pub const tigerbeetle_config = @import("../config.zig").configs.test_min;
-
-const cluster = 0;
-
-pub fn main() !void {
-    const allocator = std.testing.allocator;
-    const args = try fuzz.parse_fuzz_args(allocator);
-    var prng = std.rand.DefaultPrng.init(args.seed);
-
-    // +10 to occasionally test formatting into a buffer larger than the total data size.
-    const write_sectors_max = @divExact(constants.journal_size_headers, constants.sector_size);
-    const write_sectors = 1 + prng.random().uintLessThan(usize, write_sectors_max + 10);
-    const write_size = write_sectors * constants.sector_size;
-
-    log.info("write_size={} write_sectors={}", .{ write_size, write_sectors });
-
-    try fuzz_format_wal_headers(write_size);
-    try fuzz_format_wal_prepares(write_size);
-}
-
-pub fn fuzz_format_wal_headers(write_size_max: usize) !void {
-    assert(write_size_max > 0);
-    assert(write_size_max % @sizeOf(vsr.Header) == 0);
-    assert(write_size_max % constants.sector_size == 0);
-
-    const write = try std.testing.allocator.alloc(u8, write_size_max);
-    defer std.testing.allocator.free(write);
-
-    var offset: usize = 0;
-    while (offset < constants.journal_size_headers) {
-        const write_size = journal.format_wal_headers(cluster, offset, write);
-        defer offset += write_size;
-
-        const write_headers = std.mem.bytesAsSlice(vsr.Header, write[0..write_size]);
-        for (write_headers) |header, i| {
-            const slot = @divExact(offset, @sizeOf(vsr.Header)) + i;
-            try verify_slot_header(slot, header);
-        }
-    }
-    assert(offset == constants.journal_size_headers);
-}
-
-pub fn fuzz_format_wal_prepares(write_size_max: usize) !void {
-    assert(write_size_max > 0);
-    assert(write_size_max % @sizeOf(vsr.Header) == 0);
-    assert(write_size_max % constants.sector_size == 0);
-
-    const write = try std.testing.allocator.alloc(u8, write_size_max);
-    defer std.testing.allocator.free(write);
-
-    var offset: usize = 0;
-    while (offset < constants.journal_size_prepares) {
-        const write_size = journal.format_wal_prepares(cluster, offset, write);
-        defer offset += write_size;
-
-        var offset_checked: usize = 0;
-        while (offset_checked < write_size) {
-            const offset_header_next = std.mem.alignForward(
-                offset + offset_checked,
-                constants.message_size_max,
-            ) - offset;
-
-            if (offset_checked == offset_header_next) {
-                // Message header.
-                const slot = @divExact(offset + offset_checked, constants.message_size_max);
-                const header_bytes = write[offset_checked..][0..@sizeOf(vsr.Header)];
-                const header = std.mem.bytesToValue(vsr.Header, header_bytes);
-
-                try verify_slot_header(slot, header);
-                offset_checked += @sizeOf(vsr.Header);
-            } else {
-                // Message body.
-                const offset_message_end = std.math.min(offset_header_next, write_size);
-                const message_body_bytes = write[offset_checked..offset_message_end];
-                var byte: usize = 0;
-                for (std.mem.bytesAsSlice(usize, message_body_bytes)) |b| byte |= b;
-
-                try std.testing.expectEqual(byte, 0);
-                offset_checked = offset_message_end;
-            }
-        }
-        assert(offset_checked == write_size);
-    }
-    assert(offset == constants.journal_size_prepares);
-}
-
-fn verify_slot_header(slot: usize, header: vsr.Header) !void {
-    try std.testing.expect(header.valid_checksum());
-    try std.testing.expect(header.valid_checksum_body(&[0]u8{}));
-    try std.testing.expectEqual(header.invalid(), null);
-    try std.testing.expectEqual(header.cluster, cluster);
-    try std.testing.expectEqual(header.op, slot);
-    try std.testing.expectEqual(header.size, @sizeOf(vsr.Header));
-    if (slot == 0) {
-        try std.testing.expectEqual(header.command, .prepare);
-        try std.testing.expectEqual(header.operation, .root);
-    } else {
-        try std.testing.expectEqual(header.command, .reserved);
-    }
-}

package/src/tigerbeetle/src/vsr/marzullo.zig

@@ -1,309 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-/// Marzullo's algorithm, invented by Keith Marzullo for his Ph.D. dissertation in 1984, is an
-/// agreement algorithm used to select sources for estimating accurate time from a number of noisy
-/// time sources. NTP uses a modified form of this called the Intersection algorithm, which returns
-/// a larger interval for further statistical sampling. However, here we want the smallest interval.
-pub const Marzullo = struct {
-
-    /// The smallest interval consistent with the largest number of sources.
-    pub const Interval = struct {
-        /// The lower bound on the minimum clock offset.
-        lower_bound: i64,
-
-        /// The upper bound on the maximum clock offset.
-        upper_bound: i64,
-
-        /// The number of "true chimers" consistent with the largest number of sources.
-        sources_true: u8,
-
-        /// The number of "false chimers" falling outside this interval.
-        /// Where `sources_false` plus `sources_true` always equals the total number of sources.
-        sources_false: u8,
-    };
-
-    /// A tuple represents either the lower or upper end of a bound, and is fed as input to the
-    /// Marzullo algorithm to compute the smallest interval across all tuples.
-    /// For example, given a clock offset to a remote replica of 3s, a round trip time of 1s, and
-    /// a maximum tolerance between clocks of 100ms on either side, we might create two tuples, the
-    /// lower bound having an offset of 2.4s and the upper bound having an offset of 3.6s,
-    /// to represent the error introduced by the round trip time and by the clocks themselves.
-    pub const Tuple = struct {
-        /// An identifier, the index of the clock source in the list of clock sources:
-        source: u8,
-        offset: i64,
-        bound: enum {
-            lower,
-            upper,
-        },
-    };
-
-    /// Returns the smallest interval consistent with the largest number of sources.
-    pub fn smallest_interval(tuples: []Tuple) Interval {
-        // There are two bounds (lower and upper) per source clock offset sample.
-        const sources = @intCast(u8, @divExact(tuples.len, 2));
-
-        if (sources == 0) {
-            return Interval{
-                .lower_bound = 0,
-                .upper_bound = 0,
-                .sources_true = 0,
-                .sources_false = 0,
-            };
-        }
-
-        // Use a simpler sort implementation than the complexity of `std.sort.sort()` for safety:
-        std.sort.insertionSort(Tuple, tuples, {}, less_than);
-
-        // Here is a description of the algorithm:
-        // https://en.wikipedia.org/wiki/Marzullo%27s_algorithm#Method
-        var best: i64 = 0;
-        var count: i64 = 0;
-        var previous: ?Tuple = null;
-        var interval: Interval = undefined;
-
-        for (tuples) |tuple, i| {
-            // Verify that our sort implementation is correct:
-            if (previous) |p| {
-                assert(p.offset <= tuple.offset);
-                if (p.offset == tuple.offset) {
-                    if (p.bound != tuple.bound) {
-                        assert(p.bound == .lower and tuple.bound == .upper);
-                    } else {
-                        assert(p.source < tuple.source);
-                    }
-                }
-            }
-            previous = tuple;
-
-            // Update the current number of overlapping intervals:
-            switch (tuple.bound) {
-                .lower => count += 1,
-                .upper => count -= 1,
-            }
-            // The last upper bound tuple will have a count of one less than the lower bound.
-            // Therefore, we should never see count >= best for the last tuple:
-            if (count > best) {
-                best = count;
-                interval.lower_bound = tuple.offset;
-                interval.upper_bound = tuples[i + 1].offset;
-            } else if (count == best and tuples[i + 1].bound == .upper) {
-                // This is a tie for best overlap. Both intervals have the same number of sources.
-                // We want to choose the smaller of the two intervals:
-                const alternative = tuples[i + 1].offset - tuple.offset;
-                if (alternative < interval.upper_bound - interval.lower_bound) {
-                    interval.lower_bound = tuple.offset;
-                    interval.upper_bound = tuples[i + 1].offset;
-                }
-            }
-        }
-        assert(previous.?.bound == .upper);
-
-        // The number of false sources (ones which do not overlap the optimal interval) is the
-        // number of sources minus the value of `best`:
-        assert(best <= sources);
-        interval.sources_true = @intCast(u8, best);
-        interval.sources_false = @intCast(u8, sources - @intCast(u8, best));
-        assert(interval.sources_true + interval.sources_false == sources);
-
-        return interval;
-    }
-
-    /// Sorts the list of tuples by clock offset. If two tuples with the same offset but opposite
-    /// bounds exist, indicating that one interval ends just as another begins, then a method of
-    /// deciding which comes first is necessary. Such an occurrence can be considered an overlap
-    /// with no duration, which can be found by the algorithm by sorting the lower bound before the
-    /// upper bound. Alternatively, if such pathological overlaps are considered objectionable then
-    /// they can be avoided by sorting the upper bound before the lower bound.
-    fn less_than(context: void, a: Tuple, b: Tuple) bool {
-        _ = context;
-
-        if (a.offset < b.offset) return true;
-        if (b.offset < a.offset) return false;
-        if (a.bound == .lower and b.bound == .upper) return true;
-        if (b.bound == .lower and a.bound == .upper) return false;
-        // Use the source index to break the tie and ensure the sort is fully specified and stable
-        // so that different sort algorithms sort the same way:
-        if (a.source < b.source) return true;
-        if (b.source < a.source) return false;
-        return false;
-    }
-};
-
-fn test_smallest_interval(bounds: []const i64, smallest_interval: Marzullo.Interval) !void {
-    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena.deinit();
-
-    const allocator = arena.allocator();
-
-    var tuples = try allocator.alloc(Marzullo.Tuple, bounds.len);
-    for (bounds) |bound, i| {
-        tuples[i] = .{
-            .source = @intCast(u8, @divTrunc(i, 2)),
-            .offset = bound,
-            .bound = if (i % 2 == 0) .lower else .upper,
-        };
-    }
-
-    var interval = Marzullo.smallest_interval(tuples);
-    try std.testing.expectEqual(smallest_interval, interval);
-}
-
-test {
-    try test_smallest_interval(
-        &[_]i64{
-            11, 13,
-            10, 12,
-            8,  12,
-        },
-        Marzullo.Interval{
-            .lower_bound = 11,
-            .upper_bound = 12,
-            .sources_true = 3,
-            .sources_false = 0,
-        },
-    );
-
-    try test_smallest_interval(
-        &[_]i64{
-            8,  12,
-            11, 13,
-            14, 15,
-        },
-        Marzullo.Interval{
-            .lower_bound = 11,
-            .upper_bound = 12,
-            .sources_true = 2,
-            .sources_false = 1,
-        },
-    );
-
-    try test_smallest_interval(
-        &[_]i64{
-            -10, 10,
-            -1,  1,
-            0,   0,
-        },
-        Marzullo.Interval{
-            .lower_bound = 0,
-            .upper_bound = 0,
-            .sources_true = 3,
-            .sources_false = 0,
-        },
-    );
-
-    // The upper bound of the first interval overlaps inclusively with the lower of the last.
-    try test_smallest_interval(
-        &[_]i64{
-            8,  12,
-            10, 11,
-            8,  10,
-        },
-        Marzullo.Interval{
-            .lower_bound = 10,
-            .upper_bound = 10,
-            .sources_true = 3,
-            .sources_false = 0,
-        },
-    );
-
-    // The first smallest interval is selected. The alternative with equal overlap is 10..12.
-    // However, while this shares the same number of sources, it is not the smallest interval.
-    try test_smallest_interval(
-        &[_]i64{
-            8,  12,
-            10, 12,
-            8,  9,
-        },
-        Marzullo.Interval{
-            .lower_bound = 8,
-            .upper_bound = 9,
-            .sources_true = 2,
-            .sources_false = 1,
-        },
-    );
-
-    // The last smallest interval is selected. The alternative with equal overlap is 7..9.
-    // However, while this shares the same number of sources, it is not the smallest interval.
-    try test_smallest_interval(
-        &[_]i64{
-            7,  9,
-            7,  12,
-            10, 11,
-        },
-        Marzullo.Interval{
-            .lower_bound = 10,
-            .upper_bound = 11,
-            .sources_true = 2,
-            .sources_false = 1,
-        },
-    );
-
-    // The same idea as the previous test, but with negative offsets.
-    try test_smallest_interval(
-        &[_]i64{
-            -9,  -7,
-            -12, -7,
-            -11, -10,
-        },
-        Marzullo.Interval{
-            .lower_bound = -11,
-            .upper_bound = -10,
-            .sources_true = 2,
-            .sources_false = 1,
-        },
-    );
-
-    // A cluster of one with no remote sources.
-    try test_smallest_interval(
-        &[_]i64{},
-        Marzullo.Interval{
-            .lower_bound = 0,
-            .upper_bound = 0,
-            .sources_true = 0,
-            .sources_false = 0,
-        },
-    );
-
-    // A cluster of two with one remote source.
-    try test_smallest_interval(
-        &[_]i64{
-            1, 3,
-        },
-        Marzullo.Interval{
-            .lower_bound = 1,
-            .upper_bound = 3,
-            .sources_true = 1,
-            .sources_false = 0,
-        },
-    );
-
-    // A cluster of three with agreement.
-    try test_smallest_interval(
-        &[_]i64{
-            1, 3,
-            2, 2,
-        },
-        Marzullo.Interval{
-            .lower_bound = 2,
-            .upper_bound = 2,
-            .sources_true = 2,
-            .sources_false = 0,
-        },
-    );
-
-    // A cluster of three with no agreement, still returns the smallest interval.
-    try test_smallest_interval(
-        &[_]i64{
-            1, 3,
-            4, 5,
-        },
-        Marzullo.Interval{
-            .lower_bound = 4,
-            .upper_bound = 5,
-            .sources_true = 1,
-            .sources_false = 1,
-        },
-    );
-}