tigerbeetle-node 0.11.12 → 0.12.0

package/src/tigerbeetle/scripts/vr_state_enumerate

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-
-const messages = [
-  'prepare',
-  'prepare_ok',
-  'commit',
-  'request_state_transfer',
-  'state_transfer',
-  'start_view_change',
-  'do_view_change',
-  'start_view'
-];
-
-const views = [
-  'old_view',
-  'same_view',
-  'new_view'
-];
-
-const statuses = [
-  'normal',
-  'view_change',
-  'recovering'
-];
-
-const tuples = {};
-
-statuses.forEach(
-  function(status) {
-    views.forEach(
-      function(view) {
-        messages.forEach(
-          function(message) {
-            tuples[`${message}, ${view}, ${status}`] = true;
-          }
-        );
-      }
-    );
-  }
-);
-
-Object.keys(tuples).sort().forEach(
-  function(key) {
-    console.log(key);
-  }
-);

package/src/tigerbeetle/src/benchmark.zig

@@ -1,314 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-const constants = @import("constants.zig");
-
-const log = std.log;
-pub const log_level: std.log.Level = .err;
-
-const IO = @import("io.zig").IO;
-
-const stdx = @import("stdx.zig");
-const Storage = @import("storage.zig").Storage;
-const MessagePool = @import("message_pool.zig").MessagePool;
-const MessageBus = @import("message_bus.zig").MessageBusClient;
-const StateMachine = @import("state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = constants.message_body_size_max,
-});
-const RingBuffer = @import("ring_buffer.zig").RingBuffer;
-
-const vsr = @import("vsr.zig");
-const Client = vsr.Client(StateMachine, MessageBus);
-
-const tb = @import("tigerbeetle.zig");
-
-const batches_count = 1000;
-
-const transfers_per_batch: u32 = @divExact(
-    constants.message_size_max - @sizeOf(vsr.Header),
-    @sizeOf(tb.Transfer),
-);
-comptime {
-    assert(transfers_per_batch >= 2041);
-}
-
-const transfers_max: u32 = batches_count * transfers_per_batch;
-
-var accounts = [_]tb.Account{
-    .{
-        .id = 1,
-        .user_data = 0,
-        .reserved = [_]u8{0} ** 48,
-        .ledger = 2,
-        .code = 1,
-        .flags = .{},
-        .debits_pending = 0,
-        .debits_posted = 0,
-        .credits_pending = 0,
-        .credits_posted = 0,
-    },
-    .{
-        .id = 2,
-        .user_data = 0,
-        .reserved = [_]u8{0} ** 48,
-        .ledger = 2,
-        .code = 1,
-        .flags = .{},
-        .debits_pending = 0,
-        .debits_posted = 0,
-        .credits_pending = 0,
-        .credits_posted = 0,
-    },
-};
-var create_transfers_latency_max: i64 = 0;
-
-pub fn main() !void {
-    const stdout = std.io.getStdOut().writer();
-    const stderr = std.io.getStdErr().writer();
-
-    if (builtin.mode != .ReleaseSafe and builtin.mode != .ReleaseFast) {
-        try stderr.print("Benchmark must be built as ReleaseSafe for reasonable results.\n", .{});
-    }
-
-    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena.deinit();
-
-    const allocator = arena.allocator();
-
-    const client_id = std.crypto.random.int(u128);
-    const cluster_id: u32 = 0;
-    var address = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", constants.port)};
-
-    var io = try IO.init(32, 0);
-    defer io.deinit();
-
-    var message_pool = try MessagePool.init(allocator, .client);
-    defer message_pool.deinit(allocator);
-
-    var client = try Client.init(
-        allocator,
-        client_id,
-        cluster_id,
-        @intCast(u8, address.len),
-        &message_pool,
-        .{
-            .configuration = address[0..],
-            .io = &io,
-        },
-    );
-    defer client.deinit(allocator);
-
-    // Pre-allocate a million transfers:
-    const transfers = try allocator.alloc(tb.Transfer, transfers_max);
-    defer allocator.free(transfers);
-
-    for (transfers) |*transfer, index| {
-        transfer.* = .{
-            .id = index + 1,
-            .debit_account_id = accounts[0].id,
-            .credit_account_id = accounts[1].id,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = 0,
-            .ledger = 2,
-            .code = 1,
-            .flags = .{},
-            .amount = 1,
-            .timestamp = 0,
-        };
-    }
-
-    try wait_for_connect(&client, &io);
-
-    var queue = TimedQueue.init(&client, &io);
-    try queue.push(.{
-        .operation = StateMachine.Operation.create_accounts,
-        .data = std.mem.sliceAsBytes(accounts[0..]),
-    });
-
-    try queue.execute();
-    assert(queue.end != null);
-    assert(queue.batches.empty());
-
-    var count: u64 = 0;
-    queue.reset();
-    while (count < transfers.len) {
-        try queue.push(.{
-            .operation = .create_transfers,
-            .data = std.mem.sliceAsBytes(transfers[count..][0..transfers_per_batch]),
-        });
-        count += transfers_per_batch;
-    }
-    assert(count == transfers_max);
-
-    try queue.execute();
-    assert(queue.end != null);
-    assert(queue.batches.empty());
-
-    var ms = queue.end.? - queue.start.?;
-
-    const result: i64 = @divFloor(@intCast(i64, transfers.len * 1000), ms);
-    try stdout.print("============================================\n", .{});
-    try stdout.print("{} batches in {} ms\n", .{ batches_count, ms });
-    try stdout.print("{} transfers per second\n", .{result});
-    try stdout.print("max p100 latency per {} transfers = {}ms\n", .{
-        transfers_per_batch,
-        queue.transfers_latency_max,
-    });
-}
-
-const Batch = struct {
-    operation: StateMachine.Operation,
-    data: []u8,
-};
-
-const TimedQueue = struct {
-    batch_start: ?i64,
-    start: ?i64,
-    end: ?i64,
-    transfers_latency_max: i64,
-    client: *Client,
-    io: *IO,
-    batches: RingBuffer(Batch, batches_count, .array),
-
-    pub fn init(client: *Client, io: *IO) TimedQueue {
-        var self = TimedQueue{
-            .batch_start = null,
-            .start = null,
-            .end = null,
-            .transfers_latency_max = 0,
-            .client = client,
-            .io = io,
-            .batches = .{},
-        };
-
-        return self;
-    }
-
-    pub fn reset(self: *TimedQueue) void {
-        self.batch_start = null;
-        self.start = null;
-        self.end = null;
-        self.transfers_latency_max = 0;
-    }
-
-    pub fn push(self: *TimedQueue, batch: Batch) !void {
-        try self.batches.push(batch);
-    }
-
-    pub fn execute(self: *TimedQueue) !void {
-        assert(self.start == null);
-        assert(!self.batches.empty());
-        self.reset();
-        log.debug("executing batches...", .{});
-
-        const now = std.time.milliTimestamp();
-        self.start = now;
-        if (self.batches.head_ptr()) |starting_batch| {
-            log.debug("sending first batch...", .{});
-            self.batch_start = now;
-            const message = self.client.get_message();
-            defer self.client.unref(message);
-
-            stdx.copy_disjoint(
-                .inexact,
-                u8,
-                message.buffer[@sizeOf(vsr.Header)..],
-                std.mem.sliceAsBytes(starting_batch.data),
-            );
-            self.client.request(
-                @intCast(u128, @ptrToInt(self)),
-                TimedQueue.lap,
-                starting_batch.operation,
-                message,
-                starting_batch.data.len,
-            );
-        }
-
-        while (!self.batches.empty()) {
-            self.client.tick();
-            try self.io.run_for_ns(5 * std.time.ns_per_ms);
-        }
-    }
-
-    pub fn lap(
-        user_data: u128,
-        operation: StateMachine.Operation,
-        results: Client.Error![]const u8,
-    ) void {
-        const now = std.time.milliTimestamp();
-        const value = results catch |err| {
-            log.err("Client returned error={o}", .{@errorName(err)});
-            @panic("Client returned error during benchmarking.");
-        };
-
-        const self: *TimedQueue = @intToPtr(*TimedQueue, @intCast(usize, user_data));
-        const completed_batch: ?Batch = self.batches.pop();
-        assert(completed_batch != null);
-        assert(completed_batch.?.operation == operation);
-
-        log.debug("completed batch operation={} start={}", .{
-            completed_batch.?.operation,
-            self.batch_start,
-        });
-        const latency = now - self.batch_start.?;
-        switch (operation) {
-            .create_accounts => {
-                const create_accounts_results = std.mem.bytesAsSlice(tb.CreateAccountsResult, value);
-                if (create_accounts_results.len > 0) {
-                    log.err("CreateAccountsResults={any}", .{create_accounts_results});
-                    @panic("Unexpected result creating accounts.");
-                }
-            },
-            .create_transfers => {
-                const create_transfers_results = std.mem.bytesAsSlice(tb.CreateTransfersResult, value);
-                if (create_transfers_results.len > 0) {
-                    log.err("CreateTransfersResults={any}", .{create_transfers_results});
-                    @panic("Unexpected result creating transfers.");
-                }
-
-                if (latency > self.transfers_latency_max) {
-                    self.transfers_latency_max = latency;
-                }
-            },
-            else => unreachable,
-        }
-
-        if (self.batches.head_ptr()) |next_batch| {
-            const message = self.client.get_message();
-            defer self.client.unref(message);
-
-            stdx.copy_disjoint(
-                .inexact,
-                u8,
-                message.buffer[@sizeOf(vsr.Header)..],
-                std.mem.sliceAsBytes(next_batch.data),
-            );
-
-            self.batch_start = std.time.milliTimestamp();
-            self.client.request(
-                @intCast(u128, @ptrToInt(self)),
-                TimedQueue.lap,
-                next_batch.operation,
-                message,
-                next_batch.data.len,
-            );
-        } else {
-            log.debug("stopping timer...", .{});
-            self.end = now;
-        }
-    }
-};
-
-fn wait_for_connect(client: *Client, io: *IO) !void {
-    var ticks: u32 = 0;
-    while (ticks < 20) : (ticks += 1) {
-        client.tick();
-        // We tick IO outside of client so that an IO instance can be shared by multiple clients:
-        // Otherwise we will hit io_uring memory restrictions too quickly.
-        try io.tick();
-
-        std.time.sleep(10 * std.time.ns_per_ms);
-    }
-}

package/src/tigerbeetle/src/config.zig

@@ -1,234 +0,0 @@
-//! Raw configuration values.
-//!
-//! Code which needs these values should use `constants.zig` instead.
-//! Configuration values are set from a combination of:
-//! - default values
-//! - `root.tigerbeetle_config`
-//! - `@import("tigerbeetle_options")`
-
-const builtin = @import("builtin");
-const std = @import("std");
-
-const root = @import("root");
-// Allow setting build-time config either via `build.zig` `Options`, or via a struct in the root file.
-const build_options =
-    if (@hasDecl(root, "vsr_options")) root.vsr_options else @import("vsr_options");
-
-const vsr = @import("vsr.zig");
-const sector_size = @import("constants.zig").sector_size;
-
-pub const Config = struct {
-    pub const Cluster = ConfigCluster;
-    pub const Process = ConfigProcess;
-
-    cluster: ConfigCluster,
-    process: ConfigProcess,
-};
-
-/// Configurations which are tunable per-replica (or per-client).
-/// - Replica configs need not equal each other.
-/// - Client configs need not equal each other.
-/// - Client configs need not equal replica configs.
-/// - Replica configs can change between restarts.
-///
-/// Fields are documented within constants.zig.
-const ConfigProcess = struct {
-    log_level: std.log.Level = .info,
-    tracer_backend: TracerBackend = .none,
-    hash_log_mode: HashLogMode = .none,
-    verify: bool,
-    port: u16 = 3001,
-    address: []const u8 = "127.0.0.1",
-    memory_size_max_default: u64 = 1024 * 1024 * 1024,
-    cache_accounts_max: usize,
-    cache_transfers_max: usize,
-    cache_transfers_posted_max: usize,
-    client_request_queue_max: usize = 32,
-    lsm_manifest_node_size: usize = 16 * 1024,
-    connection_delay_min_ms: u64 = 50,
-    connection_delay_max_ms: u64 = 1000,
-    tcp_backlog: u31 = 64,
-    tcp_rcvbuf: c_int = 4 * 1024 * 1024,
-    tcp_keepalive: bool = true,
-    tcp_keepidle: c_int = 5,
-    tcp_keepintvl: c_int = 4,
-    tcp_keepcnt: c_int = 3,
-    tcp_nodelay: bool = true,
-    direct_io: bool,
-    direct_io_required: bool,
-    journal_iops_read_max: usize = 8,
-    journal_iops_write_max: usize = 8,
-    tick_ms: u63 = 10,
-    rtt_ms: u64 = 300,
-    rtt_multiple: u8 = 2,
-    backoff_min_ms: u64 = 100,
-    backoff_max_ms: u64 = 10000,
-    clock_offset_tolerance_max_ms: u64 = 10000,
-    clock_epoch_max_ms: u64 = 60000,
-    clock_synchronization_window_min_ms: u64 = 2000,
-    clock_synchronization_window_max_ms: u64 = 20000,
-};
-
-/// Configurations which are tunable per-cluster.
-/// - All replicas within a cluster must have the same configuration.
-/// - Replicas must reuse the same configuration when the binary is upgraded — they do not change
-///   over the cluster lifetime.
-/// - The storage formats generated by different ConfigClusters are incompatible.
-///
-/// Fields are documented within constants.zig.
-const ConfigCluster = struct {
-    cache_line_size: comptime_int = 64,
-    clients_max: usize,
-    pipeline_prepare_queue_max: usize = 8,
-    view_change_headers_max: usize = 8,
-    quorum_replication_max: u8 = 3,
-    journal_slot_count: usize = 1024,
-    message_size_max: usize = 1 * 1024 * 1024,
-    superblock_copies: comptime_int = 4,
-    storage_size_max: u64 = 16 * 1024 * 1024 * 1024 * 1024,
-    block_size: comptime_int = 64 * 1024,
-    lsm_levels: u7 = 7,
-    lsm_growth_factor: u32 = 8,
-    lsm_table_size_max: usize = 64 * 1024 * 1024,
-    lsm_batch_multiple: comptime_int = 4,
-    lsm_snapshots_max: usize = 32,
-    lsm_value_to_key_layout_ratio_min: comptime_int = 16,
-
-    /// The WAL requires at least two sectors of redundant headers — otherwise we could lose them all to
-    /// a single torn write. A replica needs at least one valid redundant header to determine an
-    /// (untrusted) maximum op in recover_torn_prepare(), without which it cannot truncate a torn
-    /// prepare.
-    pub const journal_slot_count_min = 2 * @divExact(sector_size, @sizeOf(vsr.Header));
-
-    pub const clients_max_min = 1;
-
-    /// The smallest possible message_size_max (for use in the simulator to improve performance).
-    /// The message body must have room for pipeline_prepare_queue_max headers in the DVC.
-    pub fn message_size_max_min(clients_max: usize) usize {
-        return std.math.max(
-            sector_size,
-            std.mem.alignForward(
-                @sizeOf(vsr.Header) + clients_max * @sizeOf(vsr.Header),
-                sector_size,
-            ),
-        );
-    }
-};
-
-pub const ConfigBase = enum {
-    production,
-    development,
-    test_min,
-    default,
-};
-
-pub const TracerBackend = enum {
-    none,
-    // Writes to a file (./tracer.json) which can be uploaded to https://ui.perfetto.dev/
-    perfetto,
-    // Sends data to https://github.com/wolfpld/tracy.
-    tracy,
-};
-
-pub const HashLogMode = enum {
-    none,
-    create,
-    check,
-};
-
-pub const configs = struct {
-    /// A good default config for production.
-    pub const default_production = Config{
-        .process = .{
-            .direct_io = true,
-            .direct_io_required = true,
-            .cache_accounts_max = 1024 * 1024,
-            .cache_transfers_max = 0,
-            .cache_transfers_posted_max = 256 * 1024,
-            .verify = false,
-        },
-        .cluster = .{
-            .clients_max = 32,
-        },
-    };
-
-    /// A good default config for local development.
-    /// (For production, use default_production instead.)
-    /// The cluster-config is compatible with the default production config.
-    pub const default_development = Config{
-        .process = .{
-            .direct_io = true,
-            .direct_io_required = false,
-            .cache_accounts_max = 1024 * 1024,
-            .cache_transfers_max = 0,
-            .cache_transfers_posted_max = 256 * 1024,
-            .verify = true,
-        },
-        .cluster = default_production.cluster,
-    };
-
-    /// Minimal test configuration — small WAL, small grid block size, etc.
-    /// Not suitable for production, but good for testing code that would be otherwise hard to reach.
-    pub const test_min = Config{
-        .process = .{
-            .direct_io = false,
-            .direct_io_required = false,
-            .cache_accounts_max = 2048,
-            .cache_transfers_max = 0,
-            .cache_transfers_posted_max = 2048,
-            .verify = true,
-        },
-        .cluster = .{
-            .clients_max = 4 + 3,
-            .pipeline_prepare_queue_max = 4,
-            .view_change_headers_max = 4,
-            .journal_slot_count = Config.Cluster.journal_slot_count_min,
-            .message_size_max = Config.Cluster.message_size_max_min(4),
-            .storage_size_max = 4 * 1024 * 1024 * 1024,
-
-            .block_size = sector_size,
-            .lsm_growth_factor = 4,
-            .lsm_table_size_max = 64 * 1024,
-        },
-    };
-
-    const default = if (@hasDecl(root, "tigerbeetle_config"))
-        root.tigerbeetle_config
-    else if (builtin.is_test)
-        test_min
-    else
-        default_development;
-
-    pub const current = current: {
-        var base = if (@hasDecl(root, "decode_events"))
-            // TODO(DJ) This is a hack to work around the absense of tigerbeetle_build_options.
-            // This should be removed once the node client is built using `zig build`.
-            default_development
-        else switch (build_options.config_base) {
-            .default => default,
-            .production => default_production,
-            .development => default_development,
-            .test_min => test_min,
-        };
-
-        // TODO Use additional build options to overwrite other fields.
-        base.process.tracer_backend = if (@hasDecl(root, "tracer_backend"))
-            // TODO(jamii)
-            // This branch is a hack used to work around the absence of tigerbeetle_build_options.
-            // This should be removed once the node client is built using `zig build`.
-            root.tracer_backend
-        else
-            // Zig's `addOptions` reuses the type, but redeclares it — identical structurally,
-            // but a different type from a nominal typing perspective.
-            @intToEnum(TracerBackend, @enumToInt(build_options.tracer_backend));
-
-        base.process.hash_log_mode = if (@hasDecl(root, "decode_events"))
-            // TODO(DJ) This is a hack to work around the absense of tigerbeetle_build_options.
-            // This should be removed once the node client is built using `zig build`.
-            .none
-        else
-            @intToEnum(HashLogMode, @enumToInt(build_options.hash_log_mode));
-
-        break :current base;
-    };
-};