tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/cli.zig

@@ -87,7 +87,7 @@ pub const Command = union(enum) {
 
 /// Parse the command line arguments passed to the tigerbeetle binary.
 /// Exits the program with a non-zero exit code if an error is found.
-pub fn parse_args(allocator: *std.mem.Allocator) Command {
+pub fn parse_args(allocator: std.mem.Allocator) Command {
     var maybe_cluster: ?[]const u8 = null;
     var maybe_replica: ?[]const u8 = null;
     var maybe_addresses: ?[]const u8 = null;
@@ -118,8 +118,10 @@ pub fn parse_args(allocator: *std.mem.Allocator) Command {
         } else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
             std.io.getStdOut().writeAll(usage) catch os.exit(1);
             os.exit(0);
-        } else {
+        } else if (mem.startsWith(u8, arg, "--")) {
             fatal("unexpected argument: '{s}'", .{arg});
+        } else {
+            fatal("unexpected argument: '{s}' (must start with '--')", .{arg});
         }
     }
 
@@ -130,7 +132,7 @@ pub fn parse_args(allocator: *std.mem.Allocator) Command {
     const replica = parse_replica(raw_replica);
 
     const dir_path = maybe_directory orelse config.directory;
-    const dir_fd = os.openZ(dir_path, os.O_CLOEXEC | os.O_RDONLY, 0) catch |err|
+    const dir_fd = os.openZ(dir_path, os.O.CLOEXEC | os.O.RDONLY, 0) catch |err|
         fatal("failed to open directory '{s}': {}", .{ dir_path, err });
 
     switch (command) {
@@ -193,7 +195,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 {
+fn parse_addresses(allocator: std.mem.Allocator, raw_addresses: []const u8) []net.Address {
     return vsr.parse_addresses(allocator, raw_addresses) catch |err| switch (err) {
         error.AddressHasTrailingComma => fatal("--addresses: invalid trailing comma", .{}),
         error.AddressLimitExceeded => {

package/src/tigerbeetle/src/config.zig

@@ -1,8 +1,8 @@
 /// Whether development or production:
 pub const deployment_environment = .development;
 
-/// The maximum log level in increasing order of verbosity (emergency=0, debug=7):
-pub const log_level = 6;
+/// The maximum log level in increasing order of verbosity (emergency=0, debug=3):
+pub const log_level = 2;
 
 /// The maximum number of replicas allowed in a cluster.
 pub const replicas_max = 6;

package/src/tigerbeetle/src/demo.zig

@@ -1,7 +1,16 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-usingnamespace @import("tigerbeetle.zig");
+const config = @import("config.zig");
+
+const tb = @import("tigerbeetle.zig");
+const Account = tb.Account;
+const Transfer = tb.Transfer;
+const Commit = tb.Commit;
+
+const CreateAccountsResult = tb.CreateAccountsResult;
+const CreateTransfersResult = tb.CreateTransfersResult;
+const CommitTransfersResult = tb.CommitTransfersResult;
 
 const IO = @import("io.zig").IO;
 const MessageBus = @import("message_bus.zig").MessageBusClient;
@@ -13,96 +22,117 @@ const Client = vsr.Client(StateMachine, MessageBus);
 
 pub const log_level: std.log.Level = .alert;
 
-pub const Demo = struct {
-    pub fn request(
-        operation: StateMachine.Operation,
-        batch: anytype,
-        on_reply: fn (
-            user_data: u128,
-            operation: StateMachine.Operation,
-            results: Client.Error![]const u8,
-        ) void,
-    ) !void {
-        const allocator = std.heap.page_allocator;
-        const client_id = std.crypto.random.int(u128);
-        const cluster_id: u32 = 0;
-        var addresses = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", config.port)};
-
-        var io = try IO.init(32, 0);
-        defer io.deinit();
-
-        var message_bus = try MessageBus.init(allocator, cluster_id, &addresses, client_id, &io);
-        defer message_bus.deinit();
-
-        var client = try Client.init(
-            allocator,
-            client_id,
-            cluster_id,
-            @intCast(u8, addresses.len),
-            &message_bus,
-        );
-        defer client.deinit();
-
-        message_bus.set_on_message(*Client, &client, Client.on_message);
-
-        var message = client.get_message() orelse unreachable;
-        defer client.unref(message);
-
-        const body = std.mem.asBytes(&batch);
-        std.mem.copy(u8, message.buffer[@sizeOf(Header)..], body);
-
-        client.request(
-            0,
-            on_reply,
-            operation,
-            message,
-            body.len,
-        );
-
-        while (client.request_queue.count > 0) {
-            client.tick();
-            try io.run_for_ns(config.tick_ms * std.time.ns_per_ms);
-        }
-    }
-
-    pub fn on_create_accounts(
+pub fn request(
+    operation: StateMachine.Operation,
+    batch: anytype,
+    on_reply: fn (
         user_data: u128,
         operation: StateMachine.Operation,
         results: Client.Error![]const u8,
-    ) void {
-        print_results(CreateAccountsResult, results);
+    ) void,
+) !void {
+    const allocator = std.heap.page_allocator;
+    const client_id = std.crypto.random.int(u128);
+    const cluster_id: u32 = 0;
+    var addresses = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", config.port)};
+
+    var io = try IO.init(32, 0);
+    defer io.deinit();
+
+    var message_bus = try MessageBus.init(allocator, cluster_id, &addresses, client_id, &io);
+    defer message_bus.deinit();
+
+    var client = try Client.init(
+        allocator,
+        client_id,
+        cluster_id,
+        @intCast(u8, addresses.len),
+        &message_bus,
+    );
+    defer client.deinit();
+
+    message_bus.set_on_message(*Client, &client, Client.on_message);
+
+    var message = client.get_message() orelse unreachable;
+    defer client.unref(message);
+
+    const body = std.mem.asBytes(&batch);
+    std.mem.copy(u8, message.buffer[@sizeOf(Header)..], body);
+
+    client.request(
+        0,
+        on_reply,
+        operation,
+        message,
+        body.len,
+    );
+
+    while (client.request_queue.count > 0) {
+        client.tick();
+        try io.run_for_ns(config.tick_ms * std.time.ns_per_ms);
     }
-
-    pub fn on_lookup_accounts(
-        user_data: u128,
-        operation: StateMachine.Operation,
-        results: Client.Error![]const u8,
-    ) void {
-        print_results(Account, results);
-    }
-
-    pub fn on_create_transfers(
-        user_data: u128,
-        operation: StateMachine.Operation,
-        results: Client.Error![]const u8,
-    ) void {
-        print_results(CreateTransfersResult, results);
-    }
-
-    pub fn on_commit_transfers(
-        user_data: u128,
-        operation: StateMachine.Operation,
-        results: Client.Error![]const u8,
-    ) void {
-        print_results(CommitTransfersResult, results);
-    }
-
-    fn print_results(comptime Results: type, results: Client.Error![]const u8) void {
-        const body = results catch unreachable;
-        const slice = std.mem.bytesAsSlice(Results, body);
-        for (slice) |result| {
-            std.debug.print("{}\n", .{result});
-        }
-        if (slice.len == 0) std.debug.print("OK\n", .{});
+}
+
+pub fn on_create_accounts(
+    user_data: u128,
+    operation: StateMachine.Operation,
+    results: Client.Error![]const u8,
+) void {
+    _ = user_data;
+    _ = operation;
+
+    print_results(CreateAccountsResult, results);
+}
+
+pub fn on_lookup_accounts(
+    user_data: u128,
+    operation: StateMachine.Operation,
+    results: Client.Error![]const u8,
+) void {
+    _ = user_data;
+    _ = operation;
+
+    print_results(Account, results);
+}
+
+pub fn on_lookup_transfers(
+    user_data: u128,
+    operation: StateMachine.Operation,
+    results: Client.Error![]const u8,
+) void {
+    _ = user_data;
+    _ = operation;
+
+    print_results(Transfer, results);
+}
+
+pub fn on_create_transfers(
+    user_data: u128,
+    operation: StateMachine.Operation,
+    results: Client.Error![]const u8,
+) void {
+    _ = user_data;
+    _ = operation;
+
+    print_results(CreateTransfersResult, results);
+}
+
+pub fn on_commit_transfers(
+    user_data: u128,
+    operation: StateMachine.Operation,
+    results: Client.Error![]const u8,
+) void {
+    _ = user_data;
+    _ = operation;
+
+    print_results(CommitTransfersResult, results);
+}
+
+fn print_results(comptime Results: type, results: Client.Error![]const u8) void {
+    const body = results catch unreachable;
+    const slice = std.mem.bytesAsSlice(Results, body);
+    for (slice) |result| {
+        std.debug.print("{}\n", .{result});
     }
-};
+    if (slice.len == 0) std.debug.print("OK\n", .{});
+}

package/src/tigerbeetle/src/demo_01_create_accounts.zig

@@ -1,5 +1,7 @@
-usingnamespace @import("tigerbeetle.zig");
-usingnamespace @import("demo.zig");
+const tb = @import("tigerbeetle.zig");
+const demo = @import("demo.zig");
+
+const Account = tb.Account;
 
 pub fn main() !void {
     const accounts = [_]Account{
@@ -29,5 +31,5 @@ pub fn main() !void {
         },
     };
 
-    try Demo.request(.create_accounts, accounts, Demo.on_create_accounts);
+    try demo.request(.create_accounts, accounts, demo.on_create_accounts);
 }

package/src/tigerbeetle/src/demo_02_lookup_accounts.zig

@@ -1,8 +1,7 @@
-usingnamespace @import("tigerbeetle.zig");
-usingnamespace @import("demo.zig");
+const demo = @import("demo.zig");
 
 pub fn main() !void {
     const ids = [_]u128{ 1, 2 };
 
-    try Demo.request(.lookup_accounts, ids, Demo.on_lookup_accounts);
+    try demo.request(.lookup_accounts, ids, demo.on_lookup_accounts);
 }

package/src/tigerbeetle/src/demo_03_create_transfers.zig

@@ -1,5 +1,7 @@
-usingnamespace @import("tigerbeetle.zig");
-usingnamespace @import("demo.zig");
+const tb = @import("tigerbeetle.zig");
+const demo = @import("demo.zig");
+
+const Transfer = tb.Transfer;
 
 pub fn main() !void {
     const transfers = [_]Transfer{
@@ -16,5 +18,5 @@ pub fn main() !void {
         },
     };
 
-    try Demo.request(.create_transfers, transfers, Demo.on_create_transfers);
+    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
 }

package/src/tigerbeetle/src/demo_04_create_transfers_two_phase_commit.zig

@@ -1,7 +1,9 @@
 const std = @import("std");
 
-usingnamespace @import("tigerbeetle.zig");
-usingnamespace @import("demo.zig");
+const tb = @import("tigerbeetle.zig");
+const demo = @import("demo.zig");
+
+const Transfer = tb.Transfer;
 
 pub fn main() !void {
     const transfers = [_]Transfer{
@@ -49,5 +51,5 @@ pub fn main() !void {
         },
     };
 
-    try Demo.request(.create_transfers, transfers, Demo.on_create_transfers);
+    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
 }

package/src/tigerbeetle/src/demo_05_accept_transfers.zig

@@ -1,5 +1,7 @@
-usingnamespace @import("tigerbeetle.zig");
-usingnamespace @import("demo.zig");
+const tb = @import("tigerbeetle.zig");
+const demo = @import("demo.zig");
+
+const Commit = tb.Commit;
 
 pub fn main() !void {
     const commits = [_]Commit{
@@ -17,5 +19,5 @@ pub fn main() !void {
         },
     };
 
-    try Demo.request(.commit_transfers, commits, Demo.on_commit_transfers);
+    try demo.request(.commit_transfers, commits, demo.on_commit_transfers);
 }

package/src/tigerbeetle/src/demo_06_reject_transfers.zig

@@ -1,5 +1,7 @@
-usingnamespace @import("tigerbeetle.zig");
-usingnamespace @import("demo.zig");
+const tb = @import("tigerbeetle.zig");
+const demo = @import("demo.zig");
+
+const Commit = tb.Commit;
 
 pub fn main() !void {
     const commits = [_]Commit{
@@ -11,5 +13,5 @@ pub fn main() !void {
         },
     };
 
-    try Demo.request(.commit_transfers, commits, Demo.on_commit_transfers);
+    try demo.request(.commit_transfers, commits, demo.on_commit_transfers);
 }

package/src/tigerbeetle/src/demo_07_lookup_transfers.zig

@@ -0,0 +1,7 @@
+const demo = @import("demo.zig");
+
+pub fn main() !void {
+    const ids = [_]u128{ 1000, 1001, 1002 };
+
+    try demo.request(.lookup_transfers, ids, demo.on_lookup_transfers);
+}

package/src/tigerbeetle/src/io/benchmark.zig

@@ -0,0 +1,238 @@
+const std = @import("std");
+const os = std.os;
+const assert = std.debug.assert;
+
+const Time = @import("../time.zig").Time;
+const IO = @import("../io.zig").IO;
+
+// 1 MB: larger than socket buffer so forces io_pending on darwin
+// Configure this value to smaller amounts to test IO scheduling overhead
+const buffer_size = 1 * 1024 * 1024;
+
+// max time for the benchmark to run
+const run_duration = 1 * std.time.ns_per_s;
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = &gpa.allocator;
+    defer {
+        const leaks = gpa.deinit();
+        assert(!leaks);
+    }
+
+    const buffer = try allocator.alloc(u8, buffer_size * 2);
+    defer allocator.free(buffer);
+    std.mem.set(u8, buffer, 0);
+
+    var timer = Time{};
+    const started = timer.monotonic();
+    var self = Context{
+        .io = try IO.init(32, 0),
+        .timer = &timer,
+        .started = started,
+        .current = started,
+        .tx = .{ .buffer = buffer[0 * buffer_size ..][0..buffer_size] },
+        .rx = .{ .buffer = buffer[1 * buffer_size ..][0..buffer_size] },
+    };
+
+    defer {
+        self.io.deinit();
+        const elapsed_ns = self.current - started;
+        const transferred_mb = @intToFloat(f64, self.transferred) / 1024 / 1024;
+
+        std.debug.print("IO throughput test: took {}ms @ {d:.2} MB/s\n", .{
+            elapsed_ns / std.time.ns_per_ms,
+            transferred_mb / (@intToFloat(f64, elapsed_ns) / std.time.ns_per_s),
+        });
+    }
+
+    // Setup the server socket
+    self.server.fd = try IO.openSocket(os.AF_INET, os.SOCK_STREAM, os.IPPROTO_TCP);
+    defer os.closeSocket(self.server.fd);
+
+    const address = try std.net.Address.parseIp4("127.0.0.1", 3131);
+    try os.setsockopt(
+        self.server.fd,
+        os.SOL_SOCKET,
+        os.SO_REUSEADDR,
+        &std.mem.toBytes(@as(c_int, 1)),
+    );
+    try os.bind(self.server.fd, &address.any, address.getOsSockLen());
+    try os.listen(self.server.fd, 1);
+
+    // Start accepting the client
+    self.io.accept(
+        *Context,
+        &self,
+        Context.on_accept,
+        &self.server.completion,
+        self.server.fd,
+    );
+
+    // Setup the client connection
+    self.tx.socket.fd = try IO.openSocket(os.AF_INET, os.SOCK_STREAM, os.IPPROTO_TCP);
+    defer os.closeSocket(self.tx.socket.fd);
+
+    self.io.connect(
+        *Context,
+        &self,
+        Context.on_connect,
+        &self.tx.socket.completion,
+        self.tx.socket.fd,
+        address,
+    );
+
+    // Run the IO loop, calling either tick() or run_for_ns() at "pseudo-random"
+    // to benchmark each io-driving execution path
+    var tick: usize = 0xdeadbeef;
+    while (self.is_running()) : (tick +%= 1) {
+        if (tick % 61 == 0) {
+            const timeout_ns = tick % (10 * std.time.ns_per_ms);
+            try self.io.run_for_ns(@intCast(u63, timeout_ns));
+        } else {
+            try self.io.tick();
+        }
+    }
+
+    // Assert that everything is connected
+    assert(self.server.fd != -1);
+    assert(self.tx.socket.fd != -1);
+    assert(self.rx.socket.fd != -1);
+
+    // Close the accepted client socket.
+    // The actual client socket + server socket are closed by defer
+    os.closeSocket(self.rx.socket.fd);
+}
+
+const Context = struct {
+    io: IO,
+    tx: Pipe,
+    rx: Pipe,
+    timer: *Time,
+    started: u64,
+    current: u64,
+    server: Socket = .{},
+    transferred: u64 = 0,
+
+    const Socket = struct {
+        fd: os.socket_t = -1,
+        completion: IO.Completion = undefined,
+    };
+    const Pipe = struct {
+        socket: Socket = .{},
+        buffer: []u8,
+        transferred: usize = 0,
+    };
+
+    fn is_running(self: Context) bool {
+        // Make sure that we're connected
+        if (self.rx.socket.fd == -1) return true;
+
+        // Make sure that we haven't run too long as configured
+        const elapsed = self.current - self.started;
+        return elapsed < run_duration;
+    }
+
+    fn on_accept(
+        self: *Context,
+        completion: *IO.Completion,
+        result: IO.AcceptError!os.socket_t,
+    ) void {
+        assert(self.rx.socket.fd == -1);
+        assert(&self.server.completion == completion);
+        self.rx.socket.fd = result catch |err| std.debug.panic("accept error {}", .{err});
+
+        // Start reading data from the accepted client socket
+        assert(self.rx.transferred == 0);
+        self.do_transfer("rx", .read, 0);
+    }
+
+    fn on_connect(
+        self: *Context,
+        completion: *IO.Completion,
+        result: IO.ConnectError!void,
+    ) void {
+        assert(self.tx.socket.fd != -1);
+        assert(&self.tx.socket.completion == completion);
+
+        // Start sending data to the server's accepted client
+        assert(self.tx.transferred == 0);
+        self.do_transfer("tx", .write, 0);
+    }
+
+    const TransferType = enum {
+        read = 0,
+        write = 1,
+    };
+
+    fn do_transfer(
+        self: *Context,
+        comptime pipe_name: []const u8,
+        comptime transfer_type: TransferType,
+        bytes: usize,
+    ) void {
+        // The type of IO to perform and what type of IO to perform next (after the current one completes).
+        const transfer_info = switch (transfer_type) {
+            .read => .{
+                .IoError = IO.RecvError,
+                .io_func = "recv",
+                .next = TransferType.write,
+            },
+            .write => .{
+                .IoError = IO.SendError,
+                .io_func = "send",
+                .next = TransferType.read,
+            },
+        };
+
+        assert(bytes <= buffer_size);
+        self.transferred += bytes;
+
+        // Check in with the benchmark timer to stop sending/receiving data
+        self.current = self.timer.monotonic();
+        if (!self.is_running())
+            return;
+
+        // Select which connection (tx or rx) depending on the type of transfer
+        const pipe = &@field(self, pipe_name);
+        pipe.transferred += bytes;
+        assert(pipe.transferred <= pipe.buffer.len);
+
+        // There's still more data to transfer on the connection
+        if (pipe.transferred < pipe.buffer.len) {
+            // Callback which calls this function again when data is transferred.
+            // Effectively loops back above.
+            const on_transfer = struct {
+                fn on_transfer(
+                    _self: *Context,
+                    completion: *IO.Completion,
+                    result: transfer_info.IoError!usize,
+                ) void {
+                    const _bytes = result catch |err| {
+                        std.debug.panic("{s} error: {}", .{ transfer_info.io_func, err });
+                    };
+                    assert(&@field(_self, pipe_name).socket.completion == completion);
+                    _self.do_transfer(pipe_name, transfer_type, _bytes);
+                }
+            }.on_transfer;
+
+            // Perform the IO with the callback for the completion
+            return @field(self.io, transfer_info.io_func)(
+                *Context,
+                self,
+                on_transfer,
+                &pipe.socket.completion,
+                pipe.socket.fd,
+                pipe.buffer[pipe.transferred..],
+            );
+        }
+
+        // This transfer type completed transferring all the bytes.
+        // Now, switch the transfer type (transfer_info.next).
+        // This means if we read to the buffer, now we write it out.
+        // Inversely, if we wrote the buffer, now we read it back.
+        // This is basically a modified echo benchmark.
+        pipe.transferred = 0;
+        self.do_transfer(pipe_name, transfer_info.next, 0);
+    }
+};