tigerbeetle-node 0.11.1 → 0.11.2

package/dist/.client.node.sha256

@@ -0,0 +1 @@
+5e64232ef290c0ed5f8b48762a2f9d03683e4a2ac5d74fc06ea594c035ec4b8b  dist/client.node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tigerbeetle-node",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "TigerBeetle Node.js client",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -13,6 +13,7 @@
     "LICENSE",
     "README.md",
     "dist",
+    "dist/.client.node.sha256",
     "!dist/client.node",
     "package.json",
     "package-lock.json",

package/src/tigerbeetle/src/cli.zig

@@ -1,16 +1,18 @@
 const std = @import("std");
 const assert = std.debug.assert;
 const fmt = std.fmt;
+const math = std.math;
 const mem = std.mem;
 const meta = std.meta;
 const net = std.net;
 const os = std.os;
 
 const config = @import("config.zig");
+const tigerbeetle = @import("tigerbeetle.zig");
 const vsr = @import("vsr.zig");
 const IO = @import("io.zig").IO;
 
-// TODO Document --memory
+// TODO Document --cache-accounts, --cache-transfers, --cache-transfers-posted
 const usage = fmt.comptimePrint(
     \\Usage:
     \\
@@ -84,7 +86,9 @@ pub const Command = union(enum) {
     start: struct {
         args_allocated: std.ArrayList([:0]const u8),
         addresses: []net.Address,
-        memory: u64,
+        cache_accounts: u32,
+        cache_transfers: u32,
+        cache_transfers_posted: u32,
         path: [:0]const u8,
     },
     version: struct {
@@ -110,7 +114,9 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
     var cluster: ?[]const u8 = null;
     var replica: ?[]const u8 = null;
     var addresses: ?[]const u8 = null;
-    var memory: ?[]const u8 = null;
+    var cache_accounts: ?[]const u8 = null;
+    var cache_transfers: ?[]const u8 = null;
+    var cache_transfers_posted: ?[]const u8 = null;
     var verbose: ?bool = null;
 
     var args = try std.process.argsWithAllocator(allocator);
@@ -140,14 +146,25 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
         try args_allocated.append(arg);
 
         if (mem.startsWith(u8, arg, "--cluster")) {
+            if (command != .format) fatal("--cluster: supported only by 'format' command", .{});
             cluster = parse_flag("--cluster", arg);
         } else if (mem.startsWith(u8, arg, "--replica")) {
+            if (command != .format) fatal("--replica: supported only by 'format' command", .{});
             replica = parse_flag("--replica", arg);
         } else if (mem.startsWith(u8, arg, "--addresses")) {
+            if (command != .start) fatal("--addresses: supported only by 'start' command", .{});
             addresses = parse_flag("--addresses", arg);
-        } else if (mem.startsWith(u8, arg, "--memory")) {
-            memory = parse_flag("--memory", arg);
+        } else if (mem.startsWith(u8, arg, "--cache-accounts")) {
+            if (command != .start) fatal("--cache-accounts: supported only by 'start' command", .{});
+            cache_accounts = parse_flag("--cache-accounts", arg);
+        } else if (mem.startsWith(u8, arg, "--cache-transfers")) {
+            if (command != .start) fatal("--cache-transfers: supported only by 'start' command", .{});
+            cache_transfers = parse_flag("--cache-transfers", arg);
+        } else if (mem.startsWith(u8, arg, "--cache-transfers-posted")) {
+            if (command != .start) fatal("--cache-transfers-posted: supported only by 'start' command", .{});
+            cache_transfers_posted = parse_flag("--cache-transfers-posted", arg);
         } else if (mem.eql(u8, arg, "--verbose")) {
+            if (command != .version) fatal("--verbose: supported only by 'version' command", .{});
             verbose = true;
         } else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
             std.io.getStdOut().writeAll(usage) catch os.exit(1);
@@ -155,6 +172,7 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
         } else if (mem.startsWith(u8, arg, "-")) {
             fatal("unexpected argument: '{s}'", .{arg});
         } else if (path == null) {
+            if (!(command == .format or command == .start)) fatal("unexpected path", .{});
             path = arg;
         } else {
             fatal("unexpected argument: '{s}' (must start with '--')", .{arg});
@@ -163,21 +181,11 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
 
     switch (command) {
         .version => {
-            if (addresses != null) fatal("--addresses: supported only by 'start' command", .{});
-            if (memory != null) fatal("--memory: supported only by 'start' command", .{});
-            if (cluster != null) fatal("--cluster: supported only by 'format' command", .{});
-            if (replica != null) fatal("--replica: supported only by 'format' command", .{});
-            if (path != null) fatal("unexpected path", .{});
-
             return Command{
                 .version = .{ .verbose = verbose orelse false },
             };
         },
         .format => {
-            if (addresses != null) fatal("--addresses: supported only by 'start' command", .{});
-            if (memory != null) fatal("--memory: supported only by 'start' command", .{});
-            if (verbose != null) fatal("--verbose: supported only by 'version' command", .{});
-
             return Command{
                 .format = .{
                     .args_allocated = args_allocated,
@@ -188,10 +196,6 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
             };
         },
         .start => {
-            if (cluster != null) fatal("--cluster: supported only by 'format' command", .{});
-            if (replica != null) fatal("--replica: supported only by 'format' command", .{});
-            if (verbose != null) fatal("--verbose: supported only by 'version' command", .{});
-
             return Command{
                 .start = .{
                     .args_allocated = args_allocated,
@@ -199,7 +203,21 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
                         allocator,
                         addresses orelse fatal("required: --addresses", .{}),
                     ),
-                    .memory = if (memory) |m| parse_size(m) else config.memory_size_max_default,
+                    .cache_accounts = parse_size_to_count(
+                        tigerbeetle.Account,
+                        cache_accounts,
+                        config.cache_accounts_max,
+                    ),
+                    .cache_transfers = parse_size_to_count(
+                        tigerbeetle.Transfer,
+                        cache_transfers,
+                        config.cache_transfers_max,
+                    ),
+                    .cache_transfers_posted = parse_size_to_count(
+                        u256, // TODO(#264): Use actual type here, once exposed.
+                        cache_transfers_posted,
+                        config.cache_transfers_posted_max,
+                    ),
                     .path = path orelse fatal("required: <path>", .{}),
                 },
             };
@@ -323,6 +341,30 @@ test "parse_size" {
     try expectEqual(@as(u64, 1000 * kib), parse_size("  1000  kb "));
 }
 
+/// Given a limit like `10GiB`, return the maximum power-of-two count of `T`s
+/// that can fit in the limit.
+fn parse_size_to_count(comptime T: type, string_opt: ?[]const u8, comptime default: u32) u32 {
+    var result: u32 = default;
+    if (string_opt) |string| {
+        const byte_size = parse_size(string);
+        const count_u64 = math.floorPowerOfTwo(u64, @divFloor(byte_size, @sizeOf(T)));
+        const count = math.cast(u32, count_u64) catch |err| switch (err) {
+            error.Overflow => fatal("size value is too large: '{s}'", .{string}),
+        };
+        if (count < 2048) fatal("size value is too small: '{s}'", .{string});
+        assert(count * @sizeOf(T) <= byte_size);
+
+        result = count;
+    }
+
+    // SetAssociativeCache requires a power-of-two cardinality and a minimal
+    // size.
+    assert(result >= 2048);
+    assert(math.isPowerOfTwo(result));
+
+    return result;
+}
+
 fn parse_replica(raw_replica: []const u8) u8 {
     comptime assert(config.replicas_max <= std.math.maxInt(u8));
     const replica = fmt.parseUnsigned(u8, raw_replica, 10) catch |err| switch (err) {

package/src/tigerbeetle/src/config.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const assert = std.debug.assert;
-const tigerbeetle = @import("tigerbeetle.zig");
 const vsr = @import("vsr.zig");
 
 const Environment = enum {
@@ -64,7 +63,7 @@ pub const cache_transfers_max = switch (deployment_environment) {
 
 /// 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 cache_transfers_pending_max = cache_transfers_max;
+pub const cache_transfers_posted_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.
@@ -383,7 +382,7 @@ comptime {
     // 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));
+    assert(std.math.isPowerOfTwo(cache_transfers_posted_max));
 }
 
 pub const is_32_bit = @sizeOf(usize) == 4; // TODO Return a compile error if we are not 32-bit.

package/src/tigerbeetle/src/lsm/grid.zig

@@ -172,9 +172,9 @@ pub fn GridType(comptime Storage: type) type {
             // Resolve reads that were seen in the cache during start_read()
             // but deferred to be asynchronously resolved on the next tick.
             //
-            // Drain directly from the queue so that new cache reads (added upon completion of old 
-            // cache reads) that can be serviced immediately aren't deferred until the next tick 
-            // (which may be milliseconds later due to IO.run_for_ns). This is necessary to ensure 
+            // Drain directly from the queue so that new cache reads (added upon completion of old
+            // cache reads) that can be serviced immediately aren't deferred until the next tick
+            // (which may be milliseconds later due to IO.run_for_ns). This is necessary to ensure
             // that groove prefetch completes promptly.
             //
             // Even still, we cap the reads processed to prevent going over

package/src/tigerbeetle/src/main.zig

@@ -46,7 +46,18 @@ pub fn main() !void {
 
     switch (parse_args) {
         .format => |*args| try Command.format(allocator, args.cluster, args.replica, args.path),
-        .start => |*args| try Command.start(&arena, args.addresses, args.memory, args.path),
+        .start => |*args| try Command.start(
+            &arena,
+            args.addresses,
+            .{
+                // TODO Tune lsm_forest_node_count better.
+                .lsm_forest_node_count = 4096,
+                .cache_entries_accounts = args.cache_accounts,
+                .cache_entries_transfers = args.cache_transfers,
+                .cache_entries_posted = args.cache_transfers_posted,
+            },
+            args.path,
+        ),
         .version => |*args| try Command.version(allocator, args.verbose),
     }
 }
@@ -114,11 +125,9 @@ const Command = struct {
     pub fn start(
         arena: *std.heap.ArenaAllocator,
         addresses: []std.net.Address,
-        memory: u64,
+        options: StateMachine.Options,
         path: [:0]const u8,
     ) !void {
-        _ = memory; // TODO
-
         const allocator = arena.allocator();
 
         var command: Command = undefined;
@@ -131,13 +140,7 @@ const Command = struct {
             .storage = &command.storage,
             .message_pool = &command.message_pool,
             .time = .{},
-            .state_machine_options = .{
-                // TODO Tune lsm_forest_node_count better.
-                .lsm_forest_node_count = 4096,
-                .cache_entries_accounts = config.cache_accounts_max,
-                .cache_entries_transfers = config.cache_transfers_max,
-                .cache_entries_posted = config.cache_transfers_pending_max,
-            },
+            .state_machine_options = options,
             .message_bus_options = .{
                 .configuration = addresses,
                 .io = &command.io,

package/src/tigerbeetle/src/state_machine.zig

@@ -785,7 +785,7 @@ pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
                 .ledger = p.ledger,
                 .code = p.code,
                 .pending_id = t.pending_id,
-                .timeout = t.timeout,
+                .timeout = 0,
                 .timestamp = t.timestamp,
                 .flags = t.flags,
                 .amount = amount,

package/src/tigerbeetle/src/unit_tests.zig

@@ -16,6 +16,7 @@ test {
 
     _ = @import("io.zig");
 
+    _ = @import("cli.zig");
     _ = @import("ewah.zig");
     _ = @import("util.zig");