tigerbeetle-node 0.10.0 → 0.11.0

package/src/tigerbeetle/scripts/pre-commit.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+# Usage:
+# ln -s ../../scripts/pre-commit.sh .git/hooks/pre-commit
+
+set -euo pipefail
+cd "$(dirname "$0")/../.."
+
+zig fmt --check .

package/src/tigerbeetle/scripts/shellcheck.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -e
+
+docker run -v "$(pwd)":/wrk -w /wrk koalaman/shellcheck scripts/*.sh

package/src/tigerbeetle/scripts/tests_on_alpine.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -e
+
+docker run --entrypoint sh -v "$(pwd)":/wrk -w /wrk alpine -c "
+set -e
+./scripts/install_zig.sh
+zig/zig build test
+./scripts/install.sh
+"

package/src/tigerbeetle/scripts/tests_on_ubuntu.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+set -e
+
+docker run --entrypoint sh -v "$(pwd)":/wrk -w /wrk ubuntu -c "
+set -e
+
+apt-get update -y
+apt-get install -y curl xz-utils
+
+./scripts/install_zig.sh
+zig/zig build test
+./scripts/install.sh
+"

package/src/tigerbeetle/src/benchmark.zig

@@ -12,7 +12,9 @@ const IO = @import("io.zig").IO;
 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);
+const StateMachine = @import("state_machine.zig").StateMachineType(Storage, .{
+    .message_body_size_max = config.message_body_size_max,
+});
 const RingBuffer = @import("ring_buffer.zig").RingBuffer;
 
 const vsr = @import("vsr.zig");
@@ -99,7 +101,7 @@ pub fn main() !void {
     // 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,

package/src/tigerbeetle/src/benchmark_array_search.zig

@@ -105,7 +105,7 @@ fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random)
             const target = value_picker[v % value_picker.len];
             const page = &pages[page_index];
             const bounds = Eytzinger.search_values(K, V, V.key_compare, &page.keys, &page.values, target);
-            const hit = bounds[binary_search(K, V, V.key_from_value, V.key_compare, bounds, target)];
+            const hit = bounds[binary_search(K, V, V.key_from_value, V.key_compare, bounds, target, .{})];
 
             assert(hit.key == target);
             if (i % pages.len == 0) v += 1;
@@ -136,7 +136,7 @@ fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random)
         while (i < layout.searches) : (i += 1) {
             const target = value_picker[v % value_picker.len];
             const page = &pages[page_picker[i % page_picker.len]];
-            const hit = page.values[binary_search(K, V, V.key_from_value, V.key_compare, page.values[0..], target)];
+            const hit = page.values[binary_search(K, V, V.key_from_value, V.key_compare, page.values[0..], target, .{})];
 
             assert(hit.key == target);
             if (i % pages.len == 0) v += 1;
@@ -307,7 +307,7 @@ fn binary_search_keys(
     assert(keys.len == layout.keys_count);
     assert(values.len == layout.values_count);
 
-    const key_index = binary_search(Key, Key, V.key_from_key, compare_keys, keys, key);
+    const key_index = binary_search(Key, Key, V.key_from_key, compare_keys, keys, key, .{});
     const key_stride = layout.values_count / layout.keys_count;
     const high = key_index * key_stride;
     if (key_index < keys.len and keys[key_index] == key) {

package/src/tigerbeetle/src/c/tb_client/thread.zig

@@ -98,7 +98,8 @@ pub fn ThreadType(
             errdefer self.allocator.free(self.packets);
 
             log.debug("init: parsing vsr addresses.", .{});
-            self.addresses = vsr.parse_addresses(self.allocator, addresses) catch |err| {
+            const address_limit = std.mem.count(u8, addresses, ",") + 1;
+            self.addresses = vsr.parse_addresses(self.allocator, addresses, address_limit) catch |err| {
                 log.err("failed to parse addresses: {}.", .{err});
                 return Error.InvalidAddress;
             };
@@ -236,6 +237,8 @@ pub fn ThreadType(
             while (self.available_messages > 0) {
                 const packet = pending.pop() orelse self.submitted.pop() orelse break;
                 const message = self.client.get_message();
+                defer self.client.unref(message);
+
                 self.available_messages -= 1;
                 self.request(packet, message);
             }
@@ -244,19 +247,19 @@ pub fn ThreadType(
         fn request(self: *Self, packet: *Packet, message: *Message) void {
             // Get the size of each request structure in the packet.data
             const request_size: usize = operation_size_of(packet.operation) orelse {
-                return self.on_complete(packet, message, error.InvalidOperation);
+                return self.on_complete(packet, error.InvalidOperation);
             };
 
             // Make sure the packet.data size is correct.
             const readable = packet.data[0..packet.data_size];
             if (readable.len == 0 or readable.len % request_size != 0) {
-                return self.on_complete(packet, message, error.InvalidDataSize);
+                return self.on_complete(packet, error.InvalidDataSize);
             }
 
             // Make sure the packet.data wouldn't overflow a message.
             const writable = message.buffer[@sizeOf(Header)..];
             if (readable.len > writable.len) {
-                return self.on_complete(packet, message, error.TooMuchData);
+                return self.on_complete(packet, error.TooMuchData);
             }
 
             // Write the packet data to the message
@@ -286,9 +289,8 @@ pub fn ThreadType(
             const self = user_data.self;
             const packet = user_data.packet;
 
-            // Complete the packet without a message as it's already unref()'s by the Client.
             assert(packet.operation == @enumToInt(op));
-            self.on_complete(packet, null, results);
+            self.on_complete(packet, results);
         }
 
         const PacketError = Client.Error || error{
@@ -300,11 +302,8 @@ pub fn ThreadType(
         fn on_complete(
             self: *Self,
             packet: *Packet,
-            message: ?*Message,
             result: PacketError![]const u8,
         ) void {
-            // Mark the message as completed
-            if (message) |m| self.client.unref(m);
             assert(self.available_messages < message_pool.messages_max_client);
             self.available_messages += 1;
 

package/src/tigerbeetle/src/c/tb_client.h

@@ -7,7 +7,6 @@
 
 typedef __uint128_t tb_uint128_t;
 
-
 typedef enum TB_ACCOUNT_FLAGS {
     TB_ACCOUNT_LINKED = 1 << 0,
     TB_ACCOUNT_DEBITS_MUST_NOT_EXCEED_CREDITS = 1 << 1,
@@ -18,20 +17,21 @@ typedef struct tb_account_t {
     tb_uint128_t id;
     tb_uint128_t user_data;
     uint8_t reserved[48];
-    uint16_t unit;
+    uint32_t ledger;
     uint16_t code;
-    uint32_t flags;
-    uint64_t debits_reserved;
-    uint64_t debits_accepted;
-    uint64_t credits_reserved;
-    uint64_t credits_accepted;
+    uint16_t flags;
+    uint64_t debits_pending;
+    uint64_t debits_posted;
+    uint64_t credits_pending;
+    uint64_t credits_posted;
     uint64_t timestamp;
 } tb_account_t;
 
 typedef enum TB_TRANSFER_FLAGS {
     TB_TRANSFER_LINKED = 1 << 0,
-    TB_TRANSFER_TWO_PHASE_COMMIT = 1 << 1,
-    TB_TRANSFER_CONDITION = 1 << 2,
+    TB_TRANSFER_PENDING = 1 << 1,
+    TB_TRANSFER_POST_PENDING_TRANSFER = 1 << 2,
+    TB_TRANSFER_VOID_PENDING_TRANSFER = 1 << 3,
 } TB_TRANSFER_FLAGS;
 
 typedef struct tb_transfer_t {
@@ -39,111 +39,131 @@ typedef struct tb_transfer_t {
     tb_uint128_t debit_account_id;
     tb_uint128_t credit_account_id;
     tb_uint128_t user_data;
-    uint8_t reserved[32];
+    tb_uint128_t reserved;
+    tb_uint128_t pending_id;
     uint64_t timeout;
-    uint32_t code;
-    uint32_t flags;
+    uint32_t ledger;
+    uint16_t code;
+    uint16_t flags;
     uint64_t amount;
     uint64_t timestamp;
 } tb_transfer_t;
 
-typedef enum TB_COMMIT_FLAGS {
-    TB_COMMIT_LINKED = 1 << 0,
-    TB_COMMIT_REJECT = 1 << 1,
-    TB_COMMIT_PREIMAGE = 1 << 2,
-} TB_COMMIT_FLAGS;
-
-typedef struct tb_commit_t {
-    tb_uint128_t id;
-    uint8_t reserved[32];
-    uint32_t code;
-    uint32_t flags;
-    uint64_t timestamp;
-} tb_commit_t;
-
 typedef enum TB_CREATE_ACCOUNT_RESULT {
     TB_CREATE_ACCOUNT_OK,
     TB_CREATE_ACCOUNT_LINKED_EVENT_FAILED,
-    TB_CREATE_ACCOUNT_EXISTS,
+    TB_CREATE_ACCOUNT_LINKED_EVENT_CHAIN_OPEN,
+    
+    TB_CREATE_ACCOUNT_RESERVED_FLAG,
+    TB_CREATE_ACCOUNT_RESERVED_FIELD,
+    
+    TB_CREATE_ACCOUNT_ID_MUST_NOT_BE_ZERO,
+    TB_CREATE_ACCOUNT_ID_MUST_NOT_BE_INT_MAX,
+    TB_CREATE_ACCOUNT_LEDGER_MUST_NOT_BE_ZERO,
+    TB_CREATE_ACCOUNT_CODE_MUST_NOT_BE_ZERO,
+    TB_CREATE_ACCOUNT_DEBITS_PENDING_MUST_BE_ZERO,
+    TB_CREATE_ACCOUNT_DEBITS_POSTED_MUST_BE_ZERO,
+    TB_CREATE_ACCOUNT_CREDITS_PENDING_MUST_BE_ZERO,
+    TB_CREATE_ACCOUNT_CREDITS_POSTED_MUST_BE_ZERO,
+
+    TB_CREATE_ACCOUNT_MUTUALLY_EXCLUSIVE_FLAGS,
+
+    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_FLAGS,
     TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_USER_DATA,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_RESERVED_FIELD,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_UNIT,
+    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_LEDGER,
     TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_CODE,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_FLAGS,
-    TB_CREATE_ACCOUNT_EXCEEDS_CREDITS,
-    TB_CREATE_ACCOUNT_EXCEEDS_DEBITS,
-    TB_CREATE_ACCOUNT_RESERVE_FAILED,
-    TB_CREATE_ACCOUNT_RESERVE_FLAG_PADDING
+    TB_CREATE_ACCOUNT_EXISTS
 } TB_CREATE_ACCOUNT_RESULT;
 
 typedef enum TB_CREATE_TRANSFER_RESULT {
     TB_CREATE_TRANSFER_OK,
     TB_CREATE_TRANSFER_LINKED_EVENT_FAILED,
-    TB_CREATE_TRANSFER_EXISTS,
+    TB_CREATE_TRANSFER_LINKED_EVENT_CHAIN_OPEN,
+
+    TB_CREATE_TRANSFER_RESERVED_FLAG,
+    TB_CREATE_TRANSFER_RESERVED_FIELD,
+    
+    TB_CREATE_TRANSFER_ID_MUST_NOT_BE_ZERO,
+    TB_CREATE_TRANSFER_ID_MUST_NOT_BE_INT_MAX,
+    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_ID_MUST_NOT_BE_ZERO,
+    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX,
+    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_ID_MUST_NOT_BE_ZERO,
+    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX,
+    TB_CREATE_TRANSFER_ACCOUNTS_MUST_BE_DIFFERENT,
+
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_BE_ZERO,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_MUST_TIMEOUT,
+
+    TB_CREATE_TRANSFER_LEDGER_MUST_NOT_BE_ZERO,
+    TB_CREATE_TRANSFER_CODE_MUST_NOT_BE_ZERO,
+    TB_CREATE_TRANSFER_AMOUNT_MUST_NOT_BE_ZERO,
+
+    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_NOT_FOUND,
+    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_NOT_FOUND,
+
+    TB_CREATE_TRANSFER_ACCOUNTS_MUST_HAVE_THE_SAME_LEDGER,
+    TB_CREATE_TRANSFER_TRANSFER_MUST_HAVE_THE_SAME_LEDGER_AS_ACCOUNTS,
+
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_FLAGS,
     TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_DEBIT_ACCOUNT_ID,
     TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_CREDIT_ACCOUNT_ID,
     TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_USER_DATA,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_RESERVED_FIELD,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_PENDING_ID,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_TIMEOUT,
     TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_CODE,
     TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_AMOUNT,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_TIMEOUT,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_FLAGS,
-    TB_CREATE_TRANSFER_EXISTS_AND_ALREADY_COMMITTED_AND_ACCEPTED,
-    TB_CREATE_TRANSFER_EXISTS_AND_ALREADY_COMMITTED_AND_REJECTED,
-    TB_CREATE_TRANSFER_RESERVED_FIELD,
-    TB_CREATE_TRANSFER_RESERVED_FLAG_PADDING,
-    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_NOT_FOUND,
-    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_NOT_FOUND,
-    TB_CREATE_TRANSFER_ACCOUNTS_ARE_THE_SAME,
-    TB_CREATE_TRANSFER_ACCOUNTS_HAVE_DIFFERENT_UNITS,
-    TB_CREATE_TRANSFER_AMOUNT_IS_ZERO,
+    TB_CREATE_TRANSFER_EXISTS,
+
+    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS_PENDING,
+    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS_PENDING,
+    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS_POSTED,
+    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS_POSTED,
+    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS,
+    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS,
+
     TB_CREATE_TRANSFER_EXCEEDS_CREDITS,
     TB_CREATE_TRANSFER_EXCEEDS_DEBITS,
-    TB_CREATE_TRANSFER_TWO_PHASE_COMMIT_MUST_TIMEOUT,
-    TB_CREATE_TRANSFER_TIMEOUT_RESERVED_FOR_TWO_PHASE_COMMIT
-} TB_CREATE_TRANSFER_RESULT;
 
-typedef enum TB_COMMIT_TRANSFER_RESULT {
-    TB_COMMIT_TRANSFER_OK,
-    TB_COMMIT_TRANSFER_LINKED_EVENT_FAILED,
-    TB_COMMIT_TRANSFER_RESERVE_FAILED,
-    TB_COMMIT_TRANSFER_RESERVE_FLAG_PADDING,
-    TB_COMMIT_TRANSFER_NOT_FOUND,
-    TB_COMMIT_TRANSFER_NOT_TWO_PHASE_COMMIT,
-    TB_COMMIT_TRANSFER_EXPIRED,
-    TB_COMMIT_TRANSFER_ALREADY_COMMITTED,
-    TB_COMMIT_TRANSFER_ALREADY_COMMITTED_BUT_ACCEPTED,
-    TB_COMMIT_TRANSFER_ALREADY_COMMITTED_BUT_REJECTED,
-    TB_COMMIT_TRANSFER_DEBIT_ACCOUNT_NOT_FOUND,
-    TB_COMMIT_TRANSFER_CREDIT_ACCOUNT_NOT_FOUND,
-    TB_COMMIT_TRANSFER_EXCEEDS_CREDITS,
-    TB_COMMIT_TRANSFER_EXCEEDS_DEBITS,
-    TB_COMMIT_TRANSFER_CONDITION_REQUIRES_PREIMAGE,
-    TB_COMMIT_TRANSFER_PREIMAGE_REQUIRES_CONDITION,
-    TB_COMMIT_TRANSFER_PREIMAGE_INVALID
-} TB_COMMIT_TRANSFER_RESULT;
+    TB_CREATE_TRANSFER_CANNOT_POST_AND_VOID_PENDING_TRANSFER,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_CANNOT_POST_OR_VOID_ANOTHER,
+    TB_CREATE_TRANSFER_TIMEOUT_RESERVED_FOR_PENDING_TRANSFER,
+
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_NOT_BE_ZERO,
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_NOT_BE_INT_MAX,
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_BE_DIFFERENT,
+
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_NOT_FOUND,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_NOT_PENDING,
+
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_DEBIT_ACCOUNT_ID,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_CREDIT_ACCOUNT_ID,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_LEDGER,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_CODE,
+
+    TB_CREATE_TRANSFER_EXCEEDS_PENDING_TRANSFER_AMOUNT,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_AMOUNT,
+
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_ALREADY_POSTED,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_ALREADY_VOIDED,
+    
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_EXPIRED,
+} TB_CREATE_TRANSFER_RESULT;
 
 typedef struct tb_create_accounts_result_t {
     uint32_t index;
-    TB_CREATE_ACCOUNT_RESULT result;
+    uint32_t result;
 } tb_create_accounts_result_t;
 
 typedef struct tb_create_transfers_result_t {
     uint32_t index;
-    TB_CREATE_TRANSFER_RESULT result;
+    uint32_t result;
 } tb_create_transfers_result_t;
 
-typedef struct tb_commit_transfers_result_t {
-    uint32_t index;
-    TB_COMMIT_TRANSFER_RESULT result;
-} tb_commit_transfers_result_t;
-
 typedef enum TB_OPERATION {
     TB_OP_CREATE_ACCOUNTS = 3,
     TB_OP_CREATE_TRANSFERS = 4,
-    TB_OP_COMMIT_TRANSFERS = 5,
-    TB_OP_LOOKUP_ACCOUNTS = 6,
-    TB_OP_LOOKUP_TRANSFERS = 7
+    TB_OP_LOOKUP_ACCOUNTS = 5,
+    TB_OP_LOOKUP_TRANSFERS = 6
 } TB_OPERATION;
 
 typedef enum TB_PACKET_STATUS {
@@ -198,4 +218,4 @@ void tb_client_deinit(
     tb_client_t client
 );
 
-#endif // TB_CLIENT_C
+#endif // TB_CLIENT_C

package/src/tigerbeetle/src/c/tb_client.zig

@@ -35,9 +35,12 @@ fn client_to_context(tb_client: tb_client_t) *ContextImplementation {
 }
 
 const DefaultContext = blk: {
+    const config = @import("../config.zig");
     const Storage = @import("../storage.zig").Storage;
     const MessageBus = @import("../message_bus.zig").MessageBusClient;
-    const StateMachine = @import("../state_machine.zig").StateMachineType(Storage);
+    const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
+        .message_body_size_max = config.message_body_size_max,
+    });
     break :blk ContextType(StateMachine, MessageBus);
 };
 

package/src/tigerbeetle/src/cli.zig

@@ -207,7 +207,7 @@ fn parse_cluster(raw_cluster: []const u8) u32 {
 
 /// Parse and allocate the addresses returning a slice into that array.
 fn parse_addresses(allocator: std.mem.Allocator, raw_addresses: []const u8) []net.Address {
-    return vsr.parse_addresses(allocator, raw_addresses) catch |err| switch (err) {
+    return vsr.parse_addresses(allocator, raw_addresses, config.replicas_max) catch |err| switch (err) {
         error.AddressHasTrailingComma => fatal("--addresses: invalid trailing comma", .{}),
         error.AddressLimitExceeded => {
             fatal("--addresses: too many addresses, at most {d} are allowed", .{

package/src/tigerbeetle/src/config.zig

@@ -1,5 +1,7 @@
 const std = @import("std");
 const assert = std.debug.assert;
+const tigerbeetle = @import("tigerbeetle.zig");
+const vsr = @import("vsr.zig");
 
 const Environment = enum {
     development,
@@ -9,8 +11,7 @@ const Environment = enum {
 
 /// Whether development or production:
 pub const deployment_environment: Environment =
-    if (@hasDecl(@import("root"), "deployment_environment")) @import("root").deployment_environment
-    else .development;
+    if (@hasDecl(@import("root"), "deployment_environment")) @import("root").deployment_environment else .development;
 
 /// The maximum log level in increasing order of verbosity (emergency=0, debug=3):
 pub const log_level = 2;
@@ -48,22 +49,22 @@ pub const memory_size_max_default = 1024 * 1024 * 1024;
 
 /// The maximum number of accounts to store in memory:
 /// This impacts the amount of memory allocated at initialization by the server.
-pub const accounts_max = switch (deployment_environment) {
-    .production => 1_000_000,
-    else => 100_000,
+pub const cache_accounts_max = switch (deployment_environment) {
+    .production => 64 * 1024,
+    else => 8 * 1024,
 };
 
 /// The maximum number of transfers to store in memory:
 /// This impacts the amount of memory allocated at initialization by the server.
 /// We allocate more capacity than the number of transfers for a safe hash table load factor.
-pub const transfers_max = switch (deployment_environment) {
-    .production => 100_000_000,
-    else => 1_000_000,
+pub const cache_transfers_max = switch (deployment_environment) {
+    .production => 1024 * 1024,
+    else => 64 * 1024,
 };
 
 /// The maximum number of two-phase transfers to store in memory:
 /// This impacts the amount of memory allocated at initialization by the server.
-pub const transfers_pending_max = transfers_max;
+pub const cache_transfers_pending_max = cache_transfers_max;
 
 /// The maximum number of batch entries in the journal file:
 /// A batch entry may contain many transfers, so this is not a limit on the number of transfers.
@@ -71,7 +72,7 @@ pub const transfers_pending_max = transfers_max;
 /// These header copies enable us to disentangle corruption from crashes and recover accordingly.
 pub const journal_slot_count = switch (deployment_environment) {
     .production => 1024,
-    else => 128,
+    else => 1024,
 };
 
 /// The maximum size of the journal file:
@@ -80,7 +81,7 @@ pub const journal_slot_count = switch (deployment_environment) {
 /// This enables static allocation of disk space so that appends cannot fail with ENOSPC.
 /// This also enables us to detect filesystem inode corruption that would change the journal size.
 // TODO remove this; just allocate a part of the total storage for the journal
-pub const journal_size_max = journal_slot_count * (128 + message_size_max);
+pub const journal_size_max = journal_slot_count * (@sizeOf(vsr.Header) + message_size_max);
 
 /// The maximum number of connections that can be held open by the server at any time:
 pub const connections_max = replicas_max + clients_max;
@@ -94,11 +95,22 @@ pub const connections_max = replicas_max + clients_max;
 /// For a 1 Gbps NIC = 125 MiB/s throughput: 2 MiB / 125 * 1000ms = 16ms for the next request.
 /// This impacts the amount of memory allocated at initialization by the server.
 pub const message_size_max = switch (deployment_environment) {
-    // Use a small message size during the simulator for improved performance.
-    .simulation => sector_size,
-    else => 1 * 1024 * 1024
+    .simulation => message_size_max_min,
+    else => 1 * 1024 * 1024,
 };
 
+pub const message_body_size_max = message_size_max - @sizeOf(vsr.Header);
+
+/// The smallest possible message_size_max (for use in the simulator to improve performance).
+/// The message body must have room for pipeline_max headers in the DVC.
+const message_size_max_min = std.math.max(
+    sector_size,
+    std.mem.alignForward(
+        @sizeOf(vsr.Header) + pipeline_max * @sizeOf(vsr.Header),
+        sector_size,
+    ),
+);
+
 /// The maximum number of Viewstamped Replication prepare messages that can be inflight at a time.
 /// This is immutable once assigned per cluster, as replicas need to know how many operations might
 /// possibly be uncommitted during a view change, and this must be constant for all replicas.
@@ -235,8 +247,15 @@ pub const block_count_max = @divExact(16 * 1024 * 1024 * 1024 * 1024, block_size
 pub const lsm_trees = 30;
 
 /// The number of levels in an LSM tree.
+/// A higher number of levels increases read amplification, as well as total storage capacity.
 pub const lsm_levels = 7;
 
+/// The number of tables at level i (0 ≤ i < lsm_levels) is `pow(lsm_growth_factor, i+1)`.
+/// A higher growth factor increases write amplification (by increasing the number of tables in
+/// level B that overlap a table in level A in a compaction), but decreases read amplification (by
+/// reducing the height of the tree and thus the number of levels that must be probed). Since read
+/// amplification can be optimized more easily (with filters and caching), we target a growth
+/// factor of 8 for lower write amplification rather than the more typical growth factor of 10.
 pub const lsm_growth_factor = 8;
 
 /// The maximum key size for an LSM tree in bytes.
@@ -305,10 +324,10 @@ pub const clock_synchronization_window_max_ms = 20000;
 pub const verify = true;
 
 // TODO Move these to a separate "internal computed constants" file.
-pub const journal_size_headers = journal_slot_count * 128; // 128 == @sizeOf(Header)
+pub const journal_size_headers = journal_slot_count * @sizeOf(vsr.Header);
 pub const journal_size_prepares = journal_slot_count * message_size_max;
 
- // TODO Move these into a separate `config_valid.zig` which we import here:
+// TODO Move these into a separate `config_valid.zig` which we import here:
 comptime {
     // vsr.parse_address assumes that config.address/config.port are valid.
     _ = std.net.Address.parseIp4(address, 0) catch unreachable;
@@ -341,8 +360,21 @@ comptime {
     assert(message_size_max % sector_size == 0);
     assert(message_size_max >= sector_size);
 
+    // ManifestLog serializes the level as a u7.
+    assert(lsm_levels > 0);
+    assert(lsm_levels <= std.math.maxInt(u7));
+
+    assert(block_size % sector_size == 0);
+    assert(lsm_table_size_max % sector_size == 0);
+    assert(lsm_table_size_max % block_size == 0);
+
     // The LSM tree uses half-measures to balance compaction.
     assert(lsm_batch_multiple % 2 == 0);
+
+    // SetAssociativeCache requires a power-of-two cardinality.
+    assert(std.math.isPowerOfTwo(cache_accounts_max));
+    assert(std.math.isPowerOfTwo(cache_transfers_max));
+    assert(std.math.isPowerOfTwo(cache_transfers_pending_max));
 }
 
 pub const is_32_bit = @sizeOf(usize) == 4; // TODO Return a compile error if we are not 32-bit.

package/src/tigerbeetle/src/demo.zig

@@ -14,7 +14,9 @@ const IO = @import("io.zig").IO;
 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);
+const StateMachine = @import("state_machine.zig").StateMachineType(Storage, .{
+    .message_body_size_max = config.message_body_size_max,
+});
 
 const vsr = @import("vsr.zig");
 const Header = vsr.Header;

package/src/tigerbeetle/src/eytzinger_benchmark.zig

@@ -105,7 +105,7 @@ fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random)
             const target = value_picker[v % value_picker.len];
             const page = &pages[page_index];
             const bounds = Eytzinger.search_values(K, V, V.key_compare, &page.keys, &page.values, target);
-            const hit = bounds[binary_search(K, V, V.key_from_value, V.key_compare, bounds, target)];
+            const hit = bounds[binary_search(K, V, V.key_from_value, V.key_compare, bounds, target, .{})];
 
             assert(hit.key == target);
             if (i % pages.len == 0) v += 1;
@@ -136,7 +136,7 @@ fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random)
         while (i < layout.searches) : (i += 1) {
             const target = value_picker[v % value_picker.len];
             const page = &pages[page_picker[i % page_picker.len]];
-            const hit = page.values[binary_search(K, V, V.key_from_value, V.key_compare, page.values[0..], target)];
+            const hit = page.values[binary_search(K, V, V.key_from_value, V.key_compare, page.values[0..], target, .{})];
 
             assert(hit.key == target);
             if (i % pages.len == 0) v += 1;
@@ -307,7 +307,7 @@ fn binary_search_keys(
     assert(keys.len == layout.keys_count);
     assert(values.len == layout.values_count);
 
-    const key_index = binary_search(Key, Key, V.key_from_key, compare_keys, keys, key);
+    const key_index = binary_search(Key, Key, V.key_from_key, compare_keys, keys, key, .{});
     const key_stride = layout.values_count / layout.keys_count;
     const high = key_index * key_stride;
     if (key_index < keys.len and keys[key_index] == key) {

package/src/tigerbeetle/src/io/linux.zig

@@ -26,7 +26,7 @@ pub const IO = struct {
         const uts = std.os.uname();
         const release = std.mem.sliceTo(&uts.release, 0);
         const version = try std.builtin.Version.parse(release);
-        if (version.major < 5 or version.minor < 5) {
+        if (version.order(std.builtin.Version{ .major = 5, .minor = 5 }) == .lt) {
             @panic("Linux kernel 5.5 or greater is required for io_uring OP_ACCEPT");
         }