tigerbeetle-node 0.8.1 → 0.9.143

package/src/tigerbeetle/src/config.zig

@@ -1,239 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-/// Whether development or production:
-pub const deployment_environment = .development;
-
-/// 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;
-
-/// The maximum number of clients allowed per cluster, where each client has a unique 128-bit ID.
-/// This impacts the amount of memory allocated at initialization by the server.
-/// This determines the size of the VR client table used to cache replies to clients by client ID.
-/// Each client has one entry in the VR client table to store the latest `message_size_max` reply.
-pub const clients_max = 32;
-
-/// The minimum number of nodes required to form a quorum for replication:
-/// Majority quorums are only required across view change and replication phases (not within).
-/// As per Flexible Paxos, provided `quorum_replication + quorum_view_change > replicas`:
-/// 1. you may increase `quorum_view_change` above a majority, so that
-/// 2. you can decrease `quorum_replication` below a majority, to optimize the common case.
-/// This improves latency by reducing the number of nodes required for synchronous replication.
-/// This reduces redundancy only in the short term, asynchronous replication will still continue.
-/// The size of the replication quorum is limited to the minimum of this value and actual majority.
-/// The size of the view change quorum will then be automatically inferred from quorum_replication.
-pub const quorum_replication_max = 3;
-
-/// The default server port to listen on if not specified in `--addresses`:
-pub const port = 3001;
-
-/// The default network interface address to listen on if not specified in `--addresses`:
-/// WARNING: Binding to all interfaces with "0.0.0.0" is dangerous and opens the server to anyone.
-/// Bind to the "127.0.0.1" loopback address to accept local connections as a safe default only.
-pub const address = "127.0.0.1";
-
-/// Where data files should be persisted by default:
-pub const directory = "/var/lib/tigerbeetle";
-
-/// 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,
-};
-
-/// 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,
-};
-
-/// 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;
-
-/// 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.
-/// We need this limit to allocate space for copies of batch headers at the start of the journal.
-/// 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,
-};
-
-/// The maximum size of the journal file:
-/// This is pre-allocated and zeroed for performance when initialized.
-/// Writes within this file never extend the filesystem inode size reducing the cost of fdatasync().
-/// 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);
-
-/// The maximum number of connections that can be held open by the server at any time:
-pub const connections_max = replicas_max + clients_max;
-
-/// The maximum size of a message in bytes:
-/// This is also the limit of all inflight data across multiple pipelined requests per connection.
-/// We may have one request of up to 2 MiB inflight or 2 pipelined requests of up to 1 MiB inflight.
-/// This impacts sequential disk write throughput, the larger the buffer the better.
-/// 2 MiB is 16,384 transfers, and a reasonable choice for sequential disk write throughput.
-/// However, this impacts bufferbloat and head-of-line blocking latency for pipelined requests.
-/// 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 = 1 * 1024 * 1024;
-
-/// 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.
-pub const pipeline_max = clients_max;
-
-/// The minimum and maximum amount of time in milliseconds to wait before initiating a connection.
-/// Exponential backoff and jitter are applied within this range.
-pub const connection_delay_min_ms = 50;
-pub const connection_delay_max_ms = 1000;
-
-/// The maximum number of outgoing messages that may be queued on a replica connection.
-pub const connection_send_queue_max_replica = std.math.max(std.math.min(clients_max, 4), 2);
-
-/// The maximum number of outgoing messages that may be queued on a client connection.
-/// The client has one in-flight request, and occasionally a ping.
-pub const connection_send_queue_max_client = 2;
-
-/// The maximum number of outgoing requests that may be queued on a client (including the in-flight request).
-pub const client_request_queue_max = 32;
-
-/// The maximum number of connections in the kernel's complete connection queue pending an accept():
-/// If the backlog argument is greater than the value in `/proc/sys/net/core/somaxconn`, then it is
-/// silently truncated to that value. Since Linux 5.4, the default in this file is 4096.
-pub const tcp_backlog = 64;
-
-/// The maximum size of a kernel socket receive buffer in bytes (or 0 to use the system default):
-/// This sets SO_RCVBUF as an alternative to the auto-tuning range in /proc/sys/net/ipv4/tcp_rmem.
-/// The value is limited by /proc/sys/net/core/rmem_max, unless the CAP_NET_ADMIN privilege exists.
-/// The kernel doubles this value to allow space for packet bookkeeping overhead.
-/// The receive buffer should ideally exceed the Bandwidth-Delay Product for maximum throughput.
-/// At the same time, be careful going beyond 4 MiB as the kernel may merge many small TCP packets,
-/// causing considerable latency spikes for large buffer sizes:
-/// https://blog.cloudflare.com/the-story-of-one-latency-spike/
-pub const tcp_rcvbuf = 4 * 1024 * 1024;
-
-/// The maximum size of a kernel socket send buffer in bytes (or 0 to use the system default):
-/// This sets SO_SNDBUF as an alternative to the auto-tuning range in /proc/sys/net/ipv4/tcp_wmem.
-/// The value is limited by /proc/sys/net/core/wmem_max, unless the CAP_NET_ADMIN privilege exists.
-/// The kernel doubles this value to allow space for packet bookkeeping overhead.
-pub const tcp_sndbuf_replica = connection_send_queue_max_replica * message_size_max;
-pub const tcp_sndbuf_client = connection_send_queue_max_client * message_size_max;
-
-/// Whether to enable TCP keepalive:
-pub const tcp_keepalive = true;
-
-/// The time (in seconds) the connection needs to be idle before sending TCP keepalive probes:
-/// Probes are not sent when the send buffer has data or the congestion window size is zero,
-/// for these cases we also need tcp_user_timeout below.
-pub const tcp_keepidle = 5;
-
-/// The time (in seconds) between individual keepalive probes:
-pub const tcp_keepintvl = 4;
-
-/// The maximum number of keepalive probes to send before dropping the connection:
-pub const tcp_keepcnt = 3;
-
-/// The time (in milliseconds) to timeout an idle connection or unacknowledged send:
-/// This timer rides on the granularity of the keepalive or retransmission timers.
-/// For example, if keepalive will only send a probe after 10s then this becomes the lower bound
-/// for tcp_user_timeout to fire, even if tcp_user_timeout is 2s. Nevertheless, this would timeout
-/// the connection at 10s rather than wait for tcp_keepcnt probes to be sent. At the same time, if
-/// tcp_user_timeout is larger than the max keepalive time then tcp_keepcnt will be ignored and
-/// more keepalive probes will be sent until tcp_user_timeout fires.
-/// For a thorough overview of how these settings interact:
-/// https://blog.cloudflare.com/when-tcp-sockets-refuse-to-die/
-pub const tcp_user_timeout = (tcp_keepidle + tcp_keepintvl * tcp_keepcnt) * 1000;
-
-/// Whether to disable Nagle's algorithm to eliminate send buffering delays:
-pub const tcp_nodelay = true;
-
-/// The minimum size of an aligned kernel page and an Advanced Format disk sector:
-/// This is necessary for direct I/O without the kernel having to fix unaligned pages with a copy.
-/// The new Advanced Format sector size is backwards compatible with the old 512 byte sector size.
-/// This should therefore never be less than 4 KiB to be future-proof when server disks are swapped.
-pub const sector_size = 4096;
-
-/// Whether to perform direct I/O to the underlying disk device:
-/// This enables several performance optimizations:
-/// * A memory copy to the kernel's page cache can be eliminated for reduced CPU utilization.
-/// * I/O can be issued immediately to the disk device without buffering delay for improved latency.
-/// This also enables several safety features:
-/// * Disk data can be scrubbed to repair latent sector errors and checksum errors proactively.
-/// * Fsync failures can be recovered from correctly.
-/// WARNING: Disabling direct I/O is unsafe; the page cache cannot be trusted after an fsync error,
-/// even after an application panic, since the kernel will mark dirty pages as clean, even
-/// when they were never written to disk.
-pub const direct_io = true;
-
-/// The maximum number of concurrent read I/O operations to allow at once.
-pub const io_depth_read = 8;
-/// The maximum number of concurrent write I/O operations to allow at once.
-pub const io_depth_write = 8;
-
-/// The number of milliseconds between each replica tick, the basic unit of time in TigerBeetle.
-/// Used to regulate heartbeats, retries and timeouts, all specified as multiples of a tick.
-pub const tick_ms = 10;
-
-/// The conservative round-trip time at startup when there is no network knowledge.
-/// Adjusted dynamically thereafter for RTT-sensitive timeouts according to network congestion.
-/// This should be set higher rather than lower to avoid flooding the network at startup.
-pub const rtt_ticks = 300 / tick_ms;
-
-/// The multiple of round-trip time for RTT-sensitive timeouts.
-pub const rtt_multiple = 2;
-
-/// The min/max bounds of exponential backoff (and jitter) to add to RTT-sensitive timeouts.
-pub const backoff_min_ticks = 100 / tick_ms;
-pub const backoff_max_ticks = 10000 / tick_ms;
-
-/// The maximum skew between two clocks to allow when considering them to be in agreement.
-/// The principle is that no two clocks tick exactly alike but some clocks more or less agree.
-/// The maximum skew across the cluster as a whole is this value times the total number of clocks.
-/// The cluster will be unavailable if the majority of clocks are all further than this value apart.
-/// Decreasing this reduces the probability of reaching agreement on synchronized time.
-/// Increasing this reduces the accuracy of synchronized time.
-pub const clock_offset_tolerance_max_ms = 10000;
-
-/// The amount of time before the clock's synchronized epoch is expired.
-/// If the epoch is expired before it can be replaced with a new synchronized epoch, then this most
-/// likely indicates either a network partition or else too many clock faults across the cluster.
-/// A new synchronized epoch will be installed as soon as these conditions resolve.
-pub const clock_epoch_max_ms = 60000;
-
-/// The amount of time to wait for enough accurate samples before synchronizing the clock.
-/// The more samples we can take per remote clock source, the more accurate our estimation becomes.
-/// This impacts cluster startup time as the leader must first wait for synchronization to complete.
-pub const clock_synchronization_window_min_ms = 2000;
-
-/// The amount of time without agreement before the clock window is expired and a new window opened.
-/// This happens where some samples have been collected but not enough to reach agreement.
-/// The quality of samples degrades as they age so at some point we throw them away and start over.
-/// This eliminates the impact of gradual clock drift on our clock offset (clock skew) measurements.
-/// If a window expires because of this then it is likely that the clock epoch will also be expired.
-pub const clock_synchronization_window_max_ms = 20000;
-
-// 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_prepares = journal_slot_count * message_size_max;
-
-comptime {
-    // vsr.parse_address assumes that config.address/config.port are valid.
-    _ = std.net.Address.parseIp4(address, 0) catch unreachable;
-    _ = @as(u16, port);
-
-    // Avoid latency issues from setting sndbuf too high:
-    assert(tcp_sndbuf_replica <= 16 * 1024 * 1024);
-    assert(tcp_sndbuf_client <= 16 * 1024 * 1024);
-
-    assert(journal_size_max == journal_size_headers + journal_size_prepares);
-}

package/src/tigerbeetle/src/demo.zig

@@ -1,125 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-const config = @import("config.zig");
-
-const tb = @import("tigerbeetle.zig");
-const Account = tb.Account;
-const Transfer = tb.Transfer;
-
-const CreateAccountsResult = tb.CreateAccountsResult;
-const CreateTransfersResult = tb.CreateTransfersResult;
-
-const IO = @import("io.zig").IO;
-const MessageBus = @import("message_bus.zig").MessageBusClient;
-const StateMachine = @import("state_machine.zig").StateMachine;
-
-const vsr = @import("vsr.zig");
-const Header = vsr.Header;
-const Client = vsr.Client(StateMachine, MessageBus);
-
-pub const log_level: std.log.Level = .alert;
-
-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 = 1;
-    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);
-
-    const message = client.get_message();
-    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(
-    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);
-}
-
-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,35 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Account = tb.Account;
-
-pub fn main() !void {
-    const accounts = [_]Account{
-        Account{
-            .id = 1,
-            .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 = 10000, // Let's start with some liquidity.
-        },
-        Account{
-            .id = 2,
-            .user_data = 0,
-            .reserved = [_]u8{0} ** 48,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 2000, // A chart of accounts code to describe this as a payable account.
-            .flags = .{},
-            .debits_pending = 0,
-            .debits_posted = 0,
-            .credits_pending = 0,
-            .credits_posted = 0,
-        },
-    };
-
-    try demo.request(.create_accounts, accounts, demo.on_create_accounts);
-}

package/src/tigerbeetle/src/demo_02_lookup_accounts.zig

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

package/src/tigerbeetle/src/demo_03_create_transfers.zig

@@ -1,24 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const transfers = [_]Transfer{
-        Transfer{
-            .id = 1,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = 0,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 1,
-            .flags = .{},
-            .amount = 1000,
-        },
-    };
-
-    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_04_create_pending_transfers.zig

@@ -1,61 +0,0 @@
-const std = @import("std");
-
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const transfers = [_]Transfer{
-        Transfer{
-            .id = 1001,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-            },
-            .amount = 8000,
-        },
-        Transfer{
-            .id = 1002,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-                .linked = true, // Link this transfer with the next transfer 1003.
-            },
-            .amount = 500,
-        },
-        Transfer{
-            .id = 1003,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-                // The last transfer in a linked chain has .linked set to false to close the chain.
-                // This transfer will succeed or fail together with transfer 1002 above.
-            },
-            .amount = 500,
-        },
-    };
-
-    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_05_post_pending_transfers.zig

@@ -1,37 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const commits = [_]Transfer{
-        Transfer{
-            .id = 2001,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 1001,
-            .timeout = 0,
-            .ledger = 0,// Honor original Transfer ledger.
-            .code = 0,// Honor original Transfer code.
-            .flags = .{ .post_pending_transfer = true }, // Post the pending two-phase transfer.
-            .amount = 0, // Inherit the amount from the pending transfer.
-        },
-        Transfer{
-            .id = 2002,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 1002,
-            .timeout = 0,
-            .ledger = 0,
-            .code = 0,
-            .flags = .{ .post_pending_transfer = true }, // Post the pending two-phase transfer.
-            .amount = 0, // Inherit the amount from the pending transfer.
-        },
-    };
-
-    try demo.request(.create_transfers, commits, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_06_void_pending_transfers.zig

@@ -1,24 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const commits = [_]Transfer{
-        Transfer{
-            .id = 2003,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 1003,
-            .timeout = 0,
-            .ledger = 0,
-            .code = 0,
-            .flags = .{ .void_pending_transfer = true },
-            .amount = 0,
-        },
-    };
-
-    try demo.request(.create_transfers, commits, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_07_lookup_transfers.zig

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

package/src/tigerbeetle/src/fifo.zig

@@ -1,104 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-/// An intrusive first in/first out linked list.
-/// The element type T must have a field called "next" of type ?*T
-pub fn FIFO(comptime T: type) type {
-    return struct {
-        const Self = @This();
-
-        in: ?*T = null,
-        out: ?*T = null,
-
-        pub fn push(self: *Self, elem: *T) void {
-            assert(elem.next == null);
-            if (self.in) |in| {
-                in.next = elem;
-                self.in = elem;
-            } else {
-                assert(self.out == null);
-                self.in = elem;
-                self.out = elem;
-            }
-        }
-
-        pub fn pop(self: *Self) ?*T {
-            const ret = self.out orelse return null;
-            self.out = ret.next;
-            ret.next = null;
-            if (self.in == ret) self.in = null;
-            return ret;
-        }
-
-        pub fn peek(self: Self) ?*T {
-            return self.out;
-        }
-
-        /// Remove an element from the FIFO. Asserts that the element is
-        /// in the FIFO. This operation is O(N), if this is done often you
-        /// probably want a different data structure.
-        pub fn remove(self: *Self, to_remove: *T) void {
-            if (to_remove == self.out) {
-                _ = self.pop();
-                return;
-            }
-            var it = self.out;
-            while (it) |elem| : (it = elem.next) {
-                if (to_remove == elem.next) {
-                    if (to_remove == self.in) self.in = elem;
-                    elem.next = to_remove.next;
-                    to_remove.next = null;
-                    break;
-                }
-            } else unreachable;
-        }
-    };
-}
-
-test "push/pop/peek/remove" {
-    const testing = @import("std").testing;
-
-    const Foo = struct { next: ?*@This() = null };
-
-    var one: Foo = .{};
-    var two: Foo = .{};
-    var three: Foo = .{};
-
-    var fifo: FIFO(Foo) = .{};
-
-    fifo.push(&one);
-    try testing.expectEqual(@as(?*Foo, &one), fifo.peek());
-
-    fifo.push(&two);
-    fifo.push(&three);
-    try testing.expectEqual(@as(?*Foo, &one), fifo.peek());
-
-    fifo.remove(&one);
-    try testing.expectEqual(@as(?*Foo, &two), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, &three), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-
-    fifo.push(&one);
-    fifo.push(&two);
-    fifo.push(&three);
-    fifo.remove(&two);
-    try testing.expectEqual(@as(?*Foo, &one), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, &three), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-
-    fifo.push(&one);
-    fifo.push(&two);
-    fifo.push(&three);
-    fifo.remove(&three);
-    try testing.expectEqual(@as(?*Foo, &one), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, &two), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-
-    fifo.push(&one);
-    fifo.push(&two);
-    fifo.remove(&two);
-    fifo.push(&three);
-    try testing.expectEqual(@as(?*Foo, &one), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, &three), fifo.pop());
-    try testing.expectEqual(@as(?*Foo, null), fifo.pop());
-}