tigerbeetle-node 0.11.12 → 0.12.0

package/src/tigerbeetle/src/lsm/table_mutable.zig

@@ -1,220 +0,0 @@
-const std = @import("std");
-const mem = std.mem;
-const math = std.math;
-const assert = std.debug.assert;
-
-const constants = @import("../constants.zig");
-const div_ceil = @import("../stdx.zig").div_ceil;
-const SetAssociativeCache = @import("set_associative_cache.zig").SetAssociativeCache;
-
-/// Range queries are not supported on the TableMutable, it must first be made immutable.
-pub fn TableMutableType(comptime Table: type) type {
-    const Key = Table.Key;
-    const Value = Table.Value;
-    const compare_keys = Table.compare_keys;
-    const key_from_value = Table.key_from_value;
-    const tombstone_from_key = Table.tombstone_from_key;
-    const tombstone = Table.tombstone;
-    const usage = Table.usage;
-
-    return struct {
-        const TableMutable = @This();
-
-        const load_factor = 50;
-        const Values = std.HashMapUnmanaged(Value, void, Table.HashMapContextValue, load_factor);
-
-        pub const ValuesCache = SetAssociativeCache(
-            Key,
-            Value,
-            Table.key_from_value,
-            struct {
-                inline fn hash(key: Key) u64 {
-                    return std.hash.Wyhash.hash(0, mem.asBytes(&key));
-                }
-            }.hash,
-            struct {
-                inline fn equal(a: Key, b: Key) bool {
-                    return compare_keys(a, b) == .eq;
-                }
-            }.equal,
-            .{},
-        );
-
-        value_count_max: u32,
-        values: Values = .{},
-
-        /// Rather than using values.count(), we count how many values we could have had if every
-        /// operation had been on a different key. This means that mistakes in calculating
-        /// commit_entries_max are much easier to catch when fuzzing, rather than requiring very
-        /// specific workloads.
-        /// Invariant: value_count_worst_case <= value_count_max
-        value_count_worst_case: u32 = 0,
-
-        /// This is used to accelerate point lookups and is not used for range queries.
-        /// Secondary index trees used only for range queries can therefore set this to null.
-        ///
-        /// The values cache is only used for the latest snapshot for simplicity.
-        /// Earlier snapshots will still be able to utilize the block cache.
-        ///
-        /// The values cache is updated (in bulk) when the mutable table is sorted and frozen,
-        /// rather than updating on every `put()`/`remove()`.
-        /// This amortizes cache inserts for hot keys in the mutable table, and avoids redundantly
-        /// storing duplicate values in both the mutable table and values cache.
-        // TODO Share cache between trees of different grooves:
-        // "A set associative cache of values shared by trees with the same key/value sizes.
-        // The value type will be []u8 and this will be shared by trees with the same value size."
-        values_cache: ?*ValuesCache,
-
-        /// `commit_entries_max` is the maximum number of Values that can be inserted by a single commit.
-        pub fn init(
-            allocator: mem.Allocator,
-            values_cache: ?*ValuesCache,
-            commit_entries_max: u32,
-        ) !TableMutable {
-            comptime assert(constants.lsm_batch_multiple > 0);
-            assert(commit_entries_max > 0);
-
-            const value_count_max = commit_entries_max * constants.lsm_batch_multiple;
-            const data_block_count = div_ceil(value_count_max, Table.data.value_count_max);
-            assert(data_block_count <= Table.data_block_count_max);
-
-            var values: Values = .{};
-            try values.ensureTotalCapacity(allocator, value_count_max);
-            errdefer values.deinit(allocator);
-
-            return TableMutable{
-                .value_count_max = value_count_max,
-                .values = values,
-                .values_cache = values_cache,
-            };
-        }
-
-        pub fn deinit(table: *TableMutable, allocator: mem.Allocator) void {
-            table.values.deinit(allocator);
-        }
-
-        pub fn get(table: *const TableMutable, key: Key) ?*const Value {
-            if (table.values.getKeyPtr(tombstone_from_key(key))) |value| {
-                return value;
-            }
-            if (table.values_cache) |cache| {
-                // Check the cache after the mutable table (see `values_cache` for explanation).
-                if (cache.get(key)) |value| return value;
-            }
-            return null;
-        }
-
-        pub fn put(table: *TableMutable, value: *const Value) void {
-            assert(table.value_count_worst_case < table.value_count_max);
-            table.value_count_worst_case += 1;
-            switch (usage) {
-                .secondary_index => {
-                    const existing = table.values.fetchRemove(value.*);
-                    if (existing) |kv| {
-                        // If there was a previous operation on this key then it must have been a remove.
-                        // The put and remove cancel out.
-                        assert(tombstone(&kv.key));
-                    } else {
-                        table.values.putAssumeCapacityNoClobber(value.*, {});
-                    }
-                },
-                .general => {
-                    // If the key is already present in the hash map, the old key will not be overwritten
-                    // by the new one if using e.g. putAssumeCapacity(). Instead we must use the lower
-                    // level getOrPut() API and manually overwrite the old key.
-                    const upsert = table.values.getOrPutAssumeCapacity(value.*);
-                    upsert.key_ptr.* = value.*;
-                },
-            }
-
-            // The hash map's load factor may allow for more capacity because of rounding:
-            assert(table.values.count() <= table.value_count_max);
-        }
-
-        pub fn remove(table: *TableMutable, value: *const Value) void {
-            assert(table.value_count_worst_case < table.value_count_max);
-            table.value_count_worst_case += 1;
-            switch (usage) {
-                .secondary_index => {
-                    const existing = table.values.fetchRemove(value.*);
-                    if (existing) |kv| {
-                        // The previous operation on this key then it must have been a put.
-                        // The put and remove cancel out.
-                        assert(!tombstone(&kv.key));
-                    } else {
-                        // If the put is already on-disk, then we need to follow it with a tombstone.
-                        // The put and the tombstone may cancel each other out later during compaction.
-                        table.values.putAssumeCapacityNoClobber(tombstone_from_key(key_from_value(value)), {});
-                    }
-                },
-                .general => {
-                    // If the key is already present in the hash map, the old key will not be overwritten
-                    // by the new one if using e.g. putAssumeCapacity(). Instead we must use the lower
-                    // level getOrPut() API and manually overwrite the old key.
-                    const upsert = table.values.getOrPutAssumeCapacity(value.*);
-                    upsert.key_ptr.* = tombstone_from_key(key_from_value(value));
-                },
-            }
-
-            assert(table.values.count() <= table.value_count_max);
-        }
-
-        /// This may return `false` even when committing would succeed — it pessimistically
-        /// assumes that none of the batch's keys are already in `table.values`.
-        pub fn can_commit_batch(table: *TableMutable, batch_count: u32) bool {
-            assert(batch_count <= table.value_count_max);
-            return (table.value_count_worst_case + batch_count) <= table.value_count_max;
-        }
-
-        pub fn clear(table: *TableMutable) void {
-            assert(table.values.count() > 0);
-            table.value_count_worst_case = 0;
-            table.values.clearRetainingCapacity();
-            assert(table.values.count() == 0);
-        }
-
-        pub fn count(table: *const TableMutable) u32 {
-            const value = @intCast(u32, table.values.count());
-            assert(value <= table.value_count_max);
-            return value;
-        }
-
-        /// The returned slice is invalidated whenever this is called for any tree.
-        pub fn sort_into_values_and_clear(
-            table: *TableMutable,
-            values_max: []Value,
-        ) []const Value {
-            assert(table.count() > 0);
-            assert(table.count() <= table.value_count_max);
-            assert(table.count() <= values_max.len);
-            assert(values_max.len == table.value_count_max);
-
-            var i: usize = 0;
-            var it = table.values.keyIterator();
-            while (it.next()) |value| : (i += 1) {
-                values_max[i] = value.*;
-
-                if (table.values_cache) |cache| {
-                    if (tombstone(value)) {
-                        cache.remove(key_from_value(value));
-                    } else {
-                        cache.insert(value);
-                    }
-                }
-            }
-
-            const values = values_max[0..i];
-            assert(values.len == table.count());
-            std.sort.sort(Value, values, {}, sort_values_by_key_in_ascending_order);
-
-            table.clear();
-            assert(table.count() == 0);
-
-            return values;
-        }
-
-        fn sort_values_by_key_in_ascending_order(_: void, a: Value, b: Value) bool {
-            return compare_keys(key_from_value(&a), key_from_value(&b)) == .lt;
-        }
-    };
-}

package/src/tigerbeetle/src/lsm/test.zig

@@ -1,438 +0,0 @@
-const std = @import("std");
-const testing = std.testing;
-const allocator = testing.allocator;
-const assert = std.debug.assert;
-const os = std.os;
-
-const constants = @import("../constants.zig");
-const vsr = @import("../vsr.zig");
-const log = std.log.scoped(.lsm_forest_test);
-
-const MessagePool = @import("../message_pool.zig").MessagePool;
-const Transfer = @import("../tigerbeetle.zig").Transfer;
-const Account = @import("../tigerbeetle.zig").Account;
-const Storage = @import("../storage.zig").Storage;
-const IO = @import("../io.zig").IO;
-const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = constants.message_body_size_max,
-});
-
-const GridType = @import("grid.zig").GridType;
-const GrooveType = @import("groove.zig").GrooveType;
-const Forest = StateMachine.Forest;
-
-const Grid = GridType(Storage);
-const SuperBlock = vsr.SuperBlockType(Storage);
-
-const Environment = struct {
-    const cluster = 32;
-    const replica = 4;
-    const storage_size_max = vsr.Zone.superblock.size().? +
-        vsr.Zone.wal_headers.size().? +
-        vsr.Zone.wal_prepares.size().? +
-        (512 + 64) * 1024 * 1024;
-
-    const node_count = 1024;
-    const cache_entries_max = 2 * 1024 * 1024;
-    const forest_options = StateMachine.forest_options(.{
-        .lsm_forest_node_count = node_count,
-        .cache_entries_accounts = cache_entries_max,
-        .cache_entries_transfers = cache_entries_max,
-        .cache_entries_posted = cache_entries_max,
-    });
-
-    const State = enum {
-        uninit,
-        init,
-        formatted,
-        superblock_open,
-        forest_open,
-        forest_compacting,
-        forest_checkpointing,
-        superblock_checkpointing,
-    };
-
-    state: State,
-    dir_fd: os.fd_t,
-    fd: os.fd_t,
-    io: IO,
-    storage: Storage,
-    message_pool: MessagePool,
-    superblock: SuperBlock,
-    superblock_context: SuperBlock.Context,
-    grid: Grid,
-    forest: Forest,
-    // We need @fieldParentPtr() of forest, so we can't use an optional Forest.
-    forest_exists: bool = false,
-
-    fn init(env: *Environment, must_create: bool) !void {
-        env.state = .uninit;
-
-        const dir_path = ".";
-        env.dir_fd = try IO.open_dir(dir_path);
-        errdefer std.os.close(env.dir_fd);
-
-        env.fd = try IO.open_file(env.dir_fd, "test_forest", storage_size_max, must_create);
-        errdefer std.os.close(env.fd);
-
-        env.io = try IO.init(128, 0);
-        errdefer env.io.deinit();
-
-        env.storage = try Storage.init(&env.io, env.fd);
-        errdefer env.storage.deinit();
-
-        env.message_pool = try MessagePool.init(allocator, .replica);
-        errdefer env.message_pool.deinit(allocator);
-
-        env.superblock = try SuperBlock.init(allocator, .{
-            .storage = &env.storage,
-            .storage_size_limit = constants.storage_size_max,
-            .message_pool = &env.message_pool,
-        });
-        env.superblock_context = undefined;
-        errdefer env.superblock.deinit(allocator);
-
-        env.grid = try Grid.init(allocator, &env.superblock);
-        errdefer env.grid.deinit(allocator);
-
-        // Forest must be initialized with an open superblock.
-        env.forest = undefined;
-        env.forest_exists = false;
-
-        env.state = .init;
-    }
-
-    fn deinit(env: *Environment) void {
-        assert(env.state != .uninit);
-        defer env.state = .uninit;
-
-        if (env.forest_exists) {
-            env.forest.deinit(allocator);
-            env.forest_exists = false;
-        }
-        env.grid.deinit(allocator);
-        env.superblock.deinit(allocator);
-        env.message_pool.deinit(allocator);
-        env.storage.deinit();
-        env.io.deinit();
-        std.os.close(env.fd);
-        std.os.close(env.dir_fd);
-    }
-
-    fn tick(env: *Environment) !void {
-        // env.grid.tick();
-        try env.io.tick();
-    }
-
-    pub fn format() !void {
-        var env: Environment = undefined;
-
-        const must_create = true;
-        try env.init(must_create);
-        defer env.deinit();
-
-        assert(env.state == .init);
-        env.superblock.format(superblock_format_callback, &env.superblock_context, .{
-            .cluster = cluster,
-            .replica = replica,
-            .storage_size_max = storage_size_max,
-        });
-
-        while (true) {
-            switch (env.state) {
-                .init => try env.tick(),
-                .formatted => break,
-                else => unreachable,
-            }
-        }
-    }
-
-    fn superblock_format_callback(superblock_context: *SuperBlock.Context) void {
-        const env = @fieldParentPtr(@This(), "superblock_context", superblock_context);
-        assert(env.state == .init);
-        env.state = .formatted;
-    }
-
-    pub fn open(env: *Environment) !void {
-        assert(env.state == .init);
-        env.superblock.open(superblock_open_callback, &env.superblock_context);
-
-        while (true) {
-            switch (env.state) {
-                .init, .superblock_open => try env.tick(),
-                .forest_open => break,
-                else => unreachable,
-            }
-        }
-    }
-
-    fn superblock_open_callback(superblock_context: *SuperBlock.Context) void {
-        const env = @fieldParentPtr(@This(), "superblock_context", superblock_context);
-        assert(env.state == .init);
-        env.state = .superblock_open;
-
-        env.forest = Forest.init(allocator, &env.grid, node_count, forest_options) catch unreachable;
-        env.forest_exists = true;
-        env.forest.open(forest_open_callback);
-    }
-
-    fn forest_open_callback(forest: *Forest) void {
-        const env = @fieldParentPtr(@This(), "forest", forest);
-        assert(env.state == .superblock_open);
-        env.state = .forest_open;
-    }
-
-    pub fn checkpoint(env: *Environment) !void {
-        assert(env.state == .forest_open);
-        env.state = .forest_checkpointing;
-        env.forest.checkpoint(forest_checkpoint_callback);
-
-        while (true) {
-            switch (env.state) {
-                .forest_checkpointing, .superblock_checkpointing => try env.tick(),
-                .forest_open => break,
-                else => unreachable,
-            }
-        }
-    }
-
-    fn forest_checkpoint_callback(forest: *Forest) void {
-        const env = @fieldParentPtr(@This(), "forest", forest);
-        assert(env.state == .forest_checkpointing);
-
-        log.debug("forest checkpointing completed!", .{});
-
-        const vsr_state = &env.superblock.staging.vsr_state;
-
-        env.state = .superblock_checkpointing;
-        env.superblock.checkpoint(
-            superblock_checkpoint_callback,
-            &env.superblock_context,
-            .{
-                .commit_min_checkpoint = vsr_state.commit_min_checkpoint + 1,
-                .commit_min = vsr_state.commit_min + 1,
-            },
-        );
-    }
-
-    fn superblock_checkpoint_callback(superblock_context: *SuperBlock.Context) void {
-        const env = @fieldParentPtr(@This(), "superblock_context", superblock_context);
-        assert(env.state == .superblock_checkpointing);
-        env.state = .forest_open;
-
-        log.debug("superblock checkpointing completed!", .{});
-    }
-
-    pub fn compact(env: *Environment, op: u64) !void {
-        assert(env.state == .forest_open);
-        env.state = .forest_compacting;
-        env.forest.compact(forest_compact_callback, op);
-
-        while (true) {
-            switch (env.state) {
-                .forest_compacting => try env.tick(),
-                .forest_open => break,
-                else => unreachable,
-            }
-        }
-    }
-
-    fn forest_compact_callback(forest: *Forest) void {
-        const env = @fieldParentPtr(@This(), "forest", forest);
-        assert(env.state == .forest_compacting);
-        env.state = .forest_open;
-    }
-
-    const Visibility = enum {
-        visible,
-        invisible,
-    };
-
-    pub fn assert_visibility(
-        env: *Environment,
-        comptime visibility: Visibility,
-        groove: anytype,
-        objects: anytype,
-        comptime commit_entries_max: u32,
-    ) !void {
-        const Groove = @TypeOf(groove.*);
-        const Object = @TypeOf(objects[0]);
-
-        const VisibilityAssertion = struct {
-            prefetch_context: Groove.PrefetchContext = undefined,
-            verify_count: usize = 0,
-            objects: []const Object,
-            groove: *Groove,
-
-            fn verify(assertion: *@This()) void {
-                assert(assertion.verify_count == 0);
-                assertion.verify_count = std.math.min(commit_entries_max, assertion.objects.len);
-                if (assertion.verify_count == 0) return;
-
-                assertion.groove.prefetch_setup(null);
-                for (assertion.objects[0..assertion.verify_count]) |*object| {
-                    assertion.groove.prefetch_enqueue(object.id);
-                }
-
-                assertion.groove.prefetch(prefetch_callback, &assertion.prefetch_context);
-            }
-
-            fn prefetch_callback(prefetch_context: *Groove.PrefetchContext) void {
-                const assertion = @fieldParentPtr(@This(), "prefetch_context", prefetch_context);
-                assert(assertion.verify_count > 0);
-
-                {
-                    for (assertion.objects[0..assertion.verify_count]) |*object| {
-                        log.debug("verifying {} for id={}", .{ visibility, object.id });
-                        const result = assertion.groove.get(object.id);
-
-                        switch (visibility) {
-                            .invisible => assert(result == null),
-                            .visible => {
-                                assert(result != null);
-                                assert(std.mem.eql(u8, std.mem.asBytes(result.?), std.mem.asBytes(object)));
-                            },
-                        }
-                    }
-                }
-
-                assertion.objects = assertion.objects[assertion.verify_count..];
-                assertion.verify_count = 0;
-                assertion.verify();
-            }
-        };
-
-        var assertion = VisibilityAssertion{ .objects = objects, .groove = groove };
-        assertion.verify();
-        while (assertion.verify_count > 0) try env.tick();
-    }
-
-    fn run() !void {
-        var env: Environment = undefined;
-
-        const must_create = false;
-        try env.init(must_create);
-
-        // We will be manually deinitializing during the test to simulate crashes and recovery.
-        // If an error occurs during re-initialization, we don't want to trip this call to deinit().
-        var crashing = false;
-        defer if (!crashing) env.deinit();
-
-        // Open the superblock then forest to start inserting accounts and transfers.
-        try env.open();
-
-        // Recording types for verification
-        var inserted = std.ArrayList(Account).init(allocator);
-        defer inserted.deinit();
-
-        const accounts_to_insert_per_op = 1; // forest_options.accounts.commit_entries_max;
-        const iterations = 4;
-
-        var op: u64 = 1;
-        var id: u128 = 1;
-        var timestamp: u64 = 42;
-        var crash_probability = std.rand.DefaultPrng.init(1337);
-
-        var iter: usize = 0;
-        while (iter < (accounts_to_insert_per_op * constants.lsm_batch_multiple * iterations)) : (iter += 1) {
-            // Insert a bunch of accounts
-
-            var i: u32 = 0;
-            while (i < accounts_to_insert_per_op) : (i += 1) {
-                defer id += 1;
-                defer timestamp += 1;
-                const account = Account{
-                    .id = id,
-                    .timestamp = timestamp,
-                    .user_data = 0,
-                    .reserved = [_]u8{0} ** 48,
-                    .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-                    .code = 1000, // A chart of accounts code to describe this as a clearing account.
-                    .flags = .{ .debits_must_not_exceed_credits = true },
-                    .debits_pending = 0,
-                    .debits_posted = 0,
-                    .credits_pending = 0,
-                    .credits_posted = 42,
-                };
-
-                // Insert an account ...
-                const groove = &env.forest.grooves.accounts;
-                groove.put(&account);
-
-                // ..and make sure it can be retrieved
-                try env.assert_visibility(
-                    .visible,
-                    &env.forest.grooves.accounts,
-                    @as([]const Account, &.{account}),
-                    forest_options.accounts.tree_options_object.commit_entries_max,
-                );
-
-                // Record the successfull insertion.
-                try inserted.append(account);
-            }
-
-            // compact the forest
-            try env.compact(op);
-            defer op += 1;
-
-            // Checkpoint when the forest finishes compaction.
-            // Don't repeat a checkpoint (commit_min must always advance).
-            const checkpoint_op = op -| constants.lsm_batch_multiple;
-            if (checkpoint_op % constants.lsm_batch_multiple == constants.lsm_batch_multiple - 1 and
-                checkpoint_op != env.superblock.staging.vsr_state.commit_min)
-            {
-                // Checkpoint the forest then superblock
-                env.superblock.staging.vsr_state.commit_min = checkpoint_op;
-                env.superblock.staging.vsr_state.commit_max = checkpoint_op;
-                try env.checkpoint();
-
-                const checkpointed = inserted.items[0 .. checkpoint_op * accounts_to_insert_per_op];
-                const uncommitted = inserted.items[checkpointed.len..];
-                log.debug("checkpointed={d} uncommitted={d}", .{ checkpointed.len, uncommitted.len });
-                assert(uncommitted.len == constants.lsm_batch_multiple * accounts_to_insert_per_op);
-
-                // Randomly initiate a crash
-                if (crash_probability.random().uintLessThanBiased(u32, 100) >= 50) {
-                    // Simulate crashing and restoring.
-                    log.debug("simulating crash", .{});
-                    crashing = true;
-                    {
-                        env.deinit();
-                        try env.init(must_create);
-
-                        // Re-open the superblock and forest.
-                        try env.open();
-
-                        // Double check the forest DOES NOT contain the un-checkpointed values (negative space)
-                        try env.assert_visibility(
-                            .invisible,
-                            &env.forest.grooves.accounts,
-                            uncommitted,
-                            forest_options.accounts.tree_options_object.commit_entries_max,
-                        );
-
-                        // Reset everything to after checkpoint
-                        op = checkpoint_op;
-                        inserted.items.len = checkpointed.len;
-                        id = checkpointed[checkpointed.len - 1].id + 1;
-                        timestamp = checkpointed[checkpointed.len - 1].timestamp + 1;
-                    }
-                    crashing = false;
-                }
-
-                // Double check the forest contains the checkpointed values (positive space)
-                try env.assert_visibility(
-                    .visible,
-                    &env.forest.grooves.accounts,
-                    checkpointed,
-                    forest_options.accounts.tree_options_object.commit_entries_max,
-                );
-            }
-        }
-    }
-};
-
-pub fn main() !void {
-    try Environment.format(); // NOTE: this can be commented out after first run to speed up testing.
-    try Environment.run(); //try do_simple();
-}