tigerbeetle-node 0.11.12 → 0.12.0

package/src/tigerbeetle/src/testing/table.zig

@@ -1,247 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-/// Parse a "table" of data with the specified schema.
-/// See test cases for example usage.
-// TODO(Zig): Change this to a a purely comptime function returning a slice
-// once Zig's "runtime value cannot be passed to comptime arg" bugs are fixed.
-pub fn parse(comptime Row: type, comptime table_string: []const u8) std.BoundedArray(Row, 128) {
-    var rows = std.BoundedArray(Row, 128).init(0) catch unreachable;
-    var row_strings = std.mem.tokenize(u8, table_string, "\n");
-    while (row_strings.next()) |row_string| {
-        // Ignore blank line.
-        if (row_string.len == 0) continue;
-
-        var columns = std.mem.tokenize(u8, row_string, " ");
-        const row = parse_data(Row, &columns);
-        rows.appendAssumeCapacity(row);
-
-        // Ignore trailing line comment.
-        if (columns.next()) |last| assert(std.mem.eql(u8, last, "//"));
-    }
-    return rows;
-}
-
-fn parse_data(comptime Data: type, tokens: *std.mem.TokenIterator(u8)) Data {
-    return switch (@typeInfo(Data)) {
-        .Optional => |info| parse_data(info.child, tokens),
-        .Enum => field(Data, tokens.next().?),
-        .Void => assert(tokens.next() == null),
-        .Bool => {
-            const token = tokens.next().?;
-            inline for (.{ "0", "false", "F" }) |t| {
-                if (std.mem.eql(u8, token, t)) return false;
-            }
-            inline for (.{ "1", "true", "T" }) |t| {
-                if (std.mem.eql(u8, token, t)) return true;
-            }
-            std.debug.panic("Unknown boolean: {s}", .{token});
-        },
-        .Int => |info| {
-            const max = std.math.maxInt(Data);
-            const token = tokens.next().?;
-            // If the first character is a letter ("a-zA-Z"), ignore it. (For example, "A1" → 1).
-            // This serves as a comment, to help visually disambiguate sequential integer columns.
-            const offset: usize = if (std.ascii.isAlpha(token[0])) 1 else 0;
-            // Negative unsigned values are computed relative to the maxInt.
-            if (info.signedness == .unsigned and token[offset] == '-') {
-                return max - (std.fmt.parseInt(Data, token[offset + 1 ..], 10) catch unreachable);
-            }
-            return std.fmt.parseInt(Data, token[offset..], 10) catch unreachable;
-        },
-        .Struct => {
-            var data: Data = undefined;
-            inline for (std.meta.fields(Data)) |value_field| {
-                // The repeated else branch seems to be necessary to keep Zig from complaining:
-                //   control flow attempts to use compile-time variable at runtime
-                if (value_field.default_value != null) {
-                    if (eat(tokens, "_")) {
-                        @field(data, value_field.name) = value_field.default_value.?;
-                    } else {
-                        @field(data, value_field.name) = parse_data(value_field.field_type, tokens);
-                    }
-                } else {
-                    @field(data, value_field.name) = parse_data(value_field.field_type, tokens);
-                }
-            }
-            return data;
-        },
-        .Array => |info| {
-            var values: Data = undefined;
-            for (values[0..]) |*value| {
-                value.* = parse_data(info.child, tokens);
-            }
-            return values;
-        },
-        .Union => |info| {
-            const variant_string = tokens.next().?;
-            inline for (info.fields) |variant_field| {
-                if (std.mem.eql(u8, variant_field.name, variant_string)) {
-                    return @unionInit(
-                        Data,
-                        variant_field.name,
-                        parse_data(variant_field.field_type, tokens),
-                    );
-                }
-            }
-            std.debug.panic("Unknown union variant: {s}", .{variant_string});
-        },
-        else => @compileError("Unimplemented column type: " ++ @typeName(Data)),
-    };
-}
-
-fn eat(tokens: *std.mem.TokenIterator(u8), token: []const u8) bool {
-    var index_before = tokens.index;
-    if (std.mem.eql(u8, tokens.next().?, token)) return true;
-    tokens.index = index_before;
-    return false;
-}
-
-/// TODO This function is a workaround for a comptime bug:
-///   error: unable to evaluate constant expression
-///   .Enum => @field(Column, column_string),
-fn field(comptime Enum: type, name: []const u8) Enum {
-    inline for (std.meta.fields(Enum)) |variant| {
-        if (std.mem.eql(u8, variant.name, name)) {
-            return @field(Enum, variant.name);
-        }
-    }
-    std.debug.panic("Unkown field name={s} for type={}", .{ name, Enum });
-}
-
-fn test_parse(
-    comptime Row: type,
-    comptime rows_expect: []const Row,
-    comptime string: []const u8,
-) !void {
-    const rows_actual = parse(Row, string).constSlice();
-    try std.testing.expectEqual(rows_expect.len, rows_actual.len);
-
-    for (rows_expect) |row, i| {
-        try std.testing.expectEqual(row, rows_actual[i]);
-    }
-}
-
-test "comment" {
-    try test_parse(struct {
-        a: u8,
-    }, &.{
-        .{ .a = 1 },
-    },
-        \\
-        \\ 1 // Comment
-        \\
-    );
-}
-
-test "enum" {
-    try test_parse(enum { a, b, c }, &.{ .c, .b, .a },
-        \\ c
-        \\ b
-        \\ a
-    );
-}
-
-test "bool" {
-    try test_parse(struct { i: bool }, &.{
-        .{ .i = false },
-        .{ .i = true },
-        .{ .i = false },
-        .{ .i = true },
-        .{ .i = false },
-        .{ .i = true },
-    },
-        \\ 0
-        \\ 1
-        \\ false
-        \\ true
-        \\ F
-        \\ T
-    );
-}
-
-test "int" {
-    try test_parse(struct { i: usize }, &.{
-        .{ .i = 1 },
-        .{ .i = 2 },
-        .{ .i = 3 },
-        .{ .i = 4 },
-        .{ .i = std.math.maxInt(usize) - 5 },
-        .{ .i = std.math.maxInt(usize) },
-    },
-        \\ 1
-        \\ 2
-        \\ A3
-        \\ a4
-        // For unsigned integers, `-n` is interpreted as `maxInt(Int) - n`.
-        \\ -5
-        \\ -0
-    );
-}
-
-test "struct" {
-    try test_parse(struct {
-        c1: enum { a, b, c, d },
-        c2: u8,
-        c3: u16 = 30,
-        c4: ?u32 = null,
-        c5: bool = false,
-    }, &.{
-        .{ .c1 = .a, .c2 = 1, .c3 = 10, .c4 = 1000, .c5 = true },
-        .{ .c1 = .b, .c2 = 2, .c3 = 20, .c4 = null, .c5 = true },
-        .{ .c1 = .c, .c2 = 3, .c3 = 30, .c4 = null, .c5 = false },
-        .{ .c1 = .d, .c2 = 4, .c3 = 30, .c4 = null, .c5 = false },
-    },
-        \\ a 1 10 1000 1
-        \\ b 2 20    _ T
-        \\ c 3  _    _ F
-        \\ d 4  _    _ _
-    );
-}
-
-test "struct (nested)" {
-    try test_parse(struct {
-        a: u32,
-        b: struct {
-            b1: u8,
-            b2: u8,
-        },
-        c: u32,
-    }, &.{
-        .{ .a = 1, .b = .{ .b1 = 2, .b2 = 3 }, .c = 4 },
-        .{ .a = 5, .b = .{ .b1 = 6, .b2 = 7 }, .c = 8 },
-    },
-        \\ 1 2 3 4
-        \\ 5 6 7 8
-    );
-}
-
-test "array" {
-    try test_parse(struct {
-        a: u32,
-        b: [2]u32,
-        c: u32,
-    }, &.{
-        .{ .a = 1, .b = .{ 2, 3 }, .c = 4 },
-        .{ .a = 5, .b = .{ 6, 7 }, .c = 8 },
-    },
-        \\ 1 2 3 4
-        \\ 5 6 7 8
-    );
-}
-
-test "union" {
-    try test_parse(union(enum) {
-        a: struct { b: u8, c: i8 },
-        d: u8,
-        e: void,
-    }, &.{
-        .{ .a = .{ .b = 1, .c = -2 } },
-        .{ .d = 3 },
-        .{ .e = {} },
-    },
-        \\a 1 -2
-        \\d 3
-        \\e
-    );
-}

package/src/tigerbeetle/src/testing/time.zig

@@ -1,84 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-pub const OffsetType = enum {
-    linear,
-    periodic,
-    step,
-    non_ideal,
-};
-
-pub const Time = struct {
-    const Self = @This();
-
-    /// The duration of a single tick in nanoseconds.
-    resolution: u64,
-
-    offset_type: OffsetType,
-
-    /// Co-efficients to scale the offset according to the `offset_type`.
-    /// Linear offset is described as A * x + B: A is the drift per tick and B the initial offset.
-    /// Periodic is described as A * sin(x * pi / B): A controls the amplitude and B the period in
-    /// terms of ticks.
-    /// Step function represents a discontinuous jump in the wall-clock time. B is the period in
-    /// which the jumps occur. A is the amplitude of the step.
-    /// Non-ideal is similar to periodic except the phase is adjusted using a random number taken
-    /// from a normal distribution with mean=0, stddev=10. Finally, a random offset (up to
-    /// offset_coefficientC) is added to the result.
-    offset_coefficient_A: i64,
-    offset_coefficient_B: i64,
-    offset_coefficient_C: u32 = 0,
-
-    prng: std.rand.DefaultPrng = std.rand.DefaultPrng.init(0),
-
-    /// The number of ticks elapsed since initialization.
-    ticks: u64 = 0,
-
-    /// The instant in time chosen as the origin of this time source.
-    epoch: i64 = 0,
-
-    pub fn monotonic(self: *Self) u64 {
-        return self.ticks * self.resolution;
-    }
-
-    pub fn realtime(self: *Self) i64 {
-        return self.epoch + @intCast(i64, self.monotonic()) - self.offset(self.ticks);
-    }
-
-    pub fn offset(self: *Self, ticks: u64) i64 {
-        switch (self.offset_type) {
-            .linear => {
-                const drift_per_tick = self.offset_coefficient_A;
-                return @intCast(i64, ticks) * drift_per_tick + @intCast(
-                    i64,
-                    self.offset_coefficient_B,
-                );
-            },
-            .periodic => {
-                const unscaled = std.math.sin(@intToFloat(f64, ticks) * 2 * std.math.pi /
-                    @intToFloat(f64, self.offset_coefficient_B));
-                const scaled = @intToFloat(f64, self.offset_coefficient_A) * unscaled;
-                return @floatToInt(i64, std.math.floor(scaled));
-            },
-            .step => {
-                return if (ticks > self.offset_coefficient_B) self.offset_coefficient_A else 0;
-            },
-            .non_ideal => {
-                const phase: f64 = @intToFloat(f64, ticks) * 2 * std.math.pi /
-                    (@intToFloat(f64, self.offset_coefficient_B) + self.prng.random().floatNorm(f64) * 10);
-                const unscaled = std.math.sin(phase);
-                const scaled = @intToFloat(f64, self.offset_coefficient_A) * unscaled;
-                return @floatToInt(i64, std.math.floor(scaled)) +
-                    self.prng.random().intRangeAtMost(
-                    i64,
-                    -@intCast(i64, self.offset_coefficient_C),
-                    self.offset_coefficient_C,
-                );
-            },
-        }
-    }
-
-    pub fn tick(self: *Self) void {
-        self.ticks += 1;
-    }
-};

package/src/tigerbeetle/src/tigerbeetle.zig

@@ -1,227 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-
-pub const Account = extern struct {
-    id: u128,
-    /// Opaque third-party identifier to link this account (many-to-one) to an external entity.
-    user_data: u128,
-    /// Reserved for accounting policy primitives.
-    reserved: [48]u8,
-    ledger: u32,
-    /// A chart of accounts code describing the type of account (e.g. clearing, settlement).
-    code: u16,
-    flags: AccountFlags,
-    debits_pending: u64,
-    debits_posted: u64,
-    credits_pending: u64,
-    credits_posted: u64,
-    timestamp: u64 = 0,
-
-    comptime {
-        assert(@sizeOf(Account) == 128);
-        assert(@bitSizeOf(Account) == @sizeOf(Account) * 8);
-    }
-
-    pub fn debits_exceed_credits(self: *const Account, amount: u64) bool {
-        return (self.flags.debits_must_not_exceed_credits and
-            self.debits_pending + self.debits_posted + amount > self.credits_posted);
-    }
-
-    pub fn credits_exceed_debits(self: *const Account, amount: u64) bool {
-        return (self.flags.credits_must_not_exceed_debits and
-            self.credits_pending + self.credits_posted + amount > self.debits_posted);
-    }
-};
-
-pub const AccountFlags = packed struct {
-    /// When the .linked flag is specified, it links an event with the next event in the batch, to
-    /// create a chain of events, of arbitrary length, which all succeed or fail together. The tail
-    /// of a chain is denoted by the first event without this flag. The last event in a batch may
-    /// therefore never have the .linked flag set as this would leave a chain open-ended. Multiple
-    /// chains or individual events may coexist within a batch to succeed or fail independently.
-    /// Events within a chain are executed within order, or are rolled back on error, so that the
-    /// effect of each event in the chain is visible to the next, and so that the chain is either
-    /// visible or invisible as a unit to subsequent events after the chain. The event that was the
-    /// first to break the chain will have a unique error result. Other events in the chain will
-    /// have their error result set to .linked_event_failed.
-    linked: bool = false,
-    debits_must_not_exceed_credits: bool = false,
-    credits_must_not_exceed_debits: bool = false,
-    padding: u13 = 0,
-
-    comptime {
-        assert(@sizeOf(AccountFlags) == @sizeOf(u16));
-    }
-};
-
-pub const Transfer = extern struct {
-    id: u128,
-    debit_account_id: u128,
-    credit_account_id: u128,
-    /// Opaque third-party identifier to link this transfer (many-to-one) to an external entity.
-    user_data: u128,
-    /// Reserved for accounting policy primitives.
-    reserved: u128,
-    /// If this transfer will post or void a pending transfer, the id of that pending transfer.
-    pending_id: u128,
-    timeout: u64,
-    ledger: u32,
-    /// A chart of accounts code describing the reason for the transfer (e.g. deposit, settlement).
-    code: u16,
-    flags: TransferFlags,
-    amount: u64,
-    timestamp: u64 = 0,
-
-    comptime {
-        assert(@sizeOf(Transfer) == 128);
-        assert(@bitSizeOf(Transfer) == @sizeOf(Transfer) * 8);
-    }
-};
-
-pub const TransferFlags = packed struct {
-    linked: bool = false,
-    pending: bool = false,
-    post_pending_transfer: bool = false,
-    void_pending_transfer: bool = false,
-    padding: u12 = 0,
-
-    comptime {
-        assert(@sizeOf(TransferFlags) == @sizeOf(u16));
-    }
-};
-
-pub const CreateAccountResult = enum(u32) {
-    ok,
-    linked_event_failed,
-    linked_event_chain_open,
-    timestamp_must_be_zero,
-
-    reserved_flag,
-    reserved_field,
-
-    id_must_not_be_zero,
-    id_must_not_be_int_max,
-    ledger_must_not_be_zero,
-    code_must_not_be_zero,
-    debits_pending_must_be_zero,
-    debits_posted_must_be_zero,
-    credits_pending_must_be_zero,
-    credits_posted_must_be_zero,
-
-    mutually_exclusive_flags,
-
-    exists_with_different_flags,
-    exists_with_different_user_data,
-    exists_with_different_ledger,
-    exists_with_different_code,
-    exists,
-};
-
-pub const CreateTransferResult = enum(u32) {
-    ok,
-    linked_event_failed,
-    linked_event_chain_open,
-    timestamp_must_be_zero,
-
-    reserved_flag,
-    reserved_field,
-
-    id_must_not_be_zero,
-    id_must_not_be_int_max,
-    debit_account_id_must_not_be_zero,
-    debit_account_id_must_not_be_int_max,
-    credit_account_id_must_not_be_zero,
-    credit_account_id_must_not_be_int_max,
-    accounts_must_be_different,
-
-    pending_id_must_be_zero,
-
-    ledger_must_not_be_zero,
-    code_must_not_be_zero,
-    amount_must_not_be_zero,
-
-    debit_account_not_found,
-    credit_account_not_found,
-
-    accounts_must_have_the_same_ledger,
-    transfer_must_have_the_same_ledger_as_accounts,
-
-    exists_with_different_flags,
-    exists_with_different_debit_account_id,
-    exists_with_different_credit_account_id,
-    exists_with_different_user_data,
-    exists_with_different_pending_id,
-    exists_with_different_timeout,
-    exists_with_different_code,
-    exists_with_different_amount,
-    exists,
-
-    overflows_debits_pending,
-    overflows_credits_pending,
-    overflows_debits_posted,
-    overflows_credits_posted,
-    overflows_debits,
-    overflows_credits,
-    overflows_timeout,
-
-    exceeds_credits,
-    exceeds_debits,
-
-    cannot_post_and_void_pending_transfer,
-    pending_transfer_cannot_post_or_void_another,
-    timeout_reserved_for_pending_transfer,
-
-    pending_id_must_not_be_zero,
-    pending_id_must_not_be_int_max,
-    pending_id_must_be_different,
-
-    pending_transfer_not_found,
-    pending_transfer_not_pending,
-
-    pending_transfer_has_different_debit_account_id,
-    pending_transfer_has_different_credit_account_id,
-    pending_transfer_has_different_ledger,
-    pending_transfer_has_different_code,
-
-    exceeds_pending_transfer_amount,
-    pending_transfer_has_different_amount,
-
-    pending_transfer_already_posted,
-    pending_transfer_already_voided,
-
-    pending_transfer_expired,
-};
-
-pub const CreateAccountsResult = extern struct {
-    index: u32,
-    result: CreateAccountResult,
-
-    comptime {
-        assert(@sizeOf(CreateAccountsResult) == 8);
-        assert(@bitSizeOf(CreateAccountsResult) == @sizeOf(CreateAccountsResult) * 8);
-    }
-};
-
-pub const CreateTransfersResult = extern struct {
-    index: u32,
-    result: CreateTransferResult,
-
-    comptime {
-        assert(@sizeOf(CreateTransfersResult) == 8);
-        assert(@bitSizeOf(CreateTransfersResult) == @sizeOf(CreateTransfersResult) * 8);
-    }
-};
-
-comptime {
-    const target = builtin.target;
-
-    if (target.os.tag != .linux and !target.isDarwin() and target.os.tag != .windows) {
-        @compileError("linux, windows or macos is required for io");
-    }
-
-    // We require little-endian architectures everywhere for efficient network deserialization:
-    if (target.cpu.arch.endian() != .Little) {
-        @compileError("big-endian systems not supported");
-    }
-}

package/src/tigerbeetle/src/time.zig

@@ -1,112 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-
-const os = std.os;
-const assert = std.debug.assert;
-const is_darwin = builtin.target.os.tag.isDarwin();
-const is_windows = builtin.target.os.tag == .windows;
-
-pub const Time = struct {
-    const Self = @This();
-
-    /// Hardware and/or software bugs can mean that the monotonic clock may regress.
-    /// One example (of many): https://bugzilla.redhat.com/show_bug.cgi?id=448449
-    /// We crash the process for safety if this ever happens, to protect against infinite loops.
-    /// It's better to crash and come back with a valid monotonic clock than get stuck forever.
-    monotonic_guard: u64 = 0,
-
-    /// A timestamp to measure elapsed time, meaningful only on the same system, not across reboots.
-    /// Always use a monotonic timestamp if the goal is to measure elapsed time.
-    /// This clock is not affected by discontinuous jumps in the system time, for example if the
-    /// system administrator manually changes the clock.
-    pub fn monotonic(self: *Self) u64 {
-        const m = blk: {
-            // Uses QueryPerformanceCounter() on windows due to it being the highest precision timer
-            // available while also accounting for time spent suspended by default:
-            // https://docs.microsoft.com/en-us/windows/win32/api/realtimeapiset/nf-realtimeapiset-queryunbiasedinterrupttime#remarks
-            if (is_windows) {
-                // QPF need not be globally cached either as it ends up being a load from read-only
-                // memory mapped to all processed by the kernel called KUSER_SHARED_DATA (See "QpcFrequency")
-                // https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/ns-ntddk-kuser_shared_data
-                // https://www.geoffchappell.com/studies/windows/km/ntoskrnl/inc/api/ntexapi_x/kuser_shared_data/index.htm
-                const qpc = os.windows.QueryPerformanceCounter();
-                const qpf = os.windows.QueryPerformanceFrequency();
-
-                // 10Mhz (1 qpc tick every 100ns) is a common QPF on modern systems.
-                // We can optimize towards this by converting to ns via a single multiply.
-                // https://github.com/microsoft/STL/blob/785143a0c73f030238ef618890fd4d6ae2b3a3a0/stl/inc/chrono#L694-L701
-                const common_qpf = 10_000_000;
-                if (qpf == common_qpf) break :blk qpc * (std.time.ns_per_s / common_qpf);
-
-                // Convert qpc to nanos using fixed point to avoid expensive extra divs and overflow.
-                const scale = (std.time.ns_per_s << 32) / qpf;
-                break :blk @truncate(u64, (@as(u96, qpc) * scale) >> 32);
-            }
-
-            // Uses mach_continuous_time() instead of mach_absolute_time() as it counts while suspended.
-            // https://developer.apple.com/documentation/kernel/1646199-mach_continuous_time
-            // https://opensource.apple.com/source/Libc/Libc-1158.1.2/gen/clock_gettime.c.auto.html
-            if (is_darwin) {
-                const darwin = struct {
-                    const mach_timebase_info_t = os.darwin.mach_timebase_info_data;
-                    extern "c" fn mach_timebase_info(info: *mach_timebase_info_t) os.darwin.kern_return_t;
-                    extern "c" fn mach_continuous_time() u64;
-                };
-
-                // mach_timebase_info() called through libc already does global caching for us
-                // https://opensource.apple.com/source/xnu/xnu-7195.81.3/libsyscall/wrappers/mach_timebase_info.c.auto.html
-                var info: darwin.mach_timebase_info_t = undefined;
-                if (darwin.mach_timebase_info(&info) != 0) @panic("mach_timebase_info() failed");
-
-                const now = darwin.mach_continuous_time();
-                return (now * info.numer) / info.denom;
-            }
-
-            // The true monotonic clock on Linux is not in fact CLOCK_MONOTONIC:
-            // CLOCK_MONOTONIC excludes elapsed time while the system is suspended (e.g. VM migration).
-            // CLOCK_BOOTTIME is the same as CLOCK_MONOTONIC but includes elapsed time during a suspend.
-            // For more detail and why CLOCK_MONOTONIC_RAW is even worse than CLOCK_MONOTONIC,
-            // see https://github.com/ziglang/zig/pull/933#discussion_r656021295.
-            var ts: os.timespec = undefined;
-            os.clock_gettime(os.CLOCK.BOOTTIME, &ts) catch @panic("CLOCK_BOOTTIME required");
-            break :blk @intCast(u64, ts.tv_sec) * std.time.ns_per_s + @intCast(u64, ts.tv_nsec);
-        };
-
-        // "Oops!...I Did It Again"
-        if (m < self.monotonic_guard) @panic("a hardware/kernel bug regressed the monotonic clock");
-        self.monotonic_guard = m;
-        return m;
-    }
-
-    /// A timestamp to measure real (i.e. wall clock) time, meaningful across systems, and reboots.
-    /// This clock is affected by discontinuous jumps in the system time.
-    pub fn realtime(_: *Self) i64 {
-        if (is_windows) {
-            const kernel32 = struct {
-                extern "kernel32" fn GetSystemTimePreciseAsFileTime(
-                    lpFileTime: *os.windows.FILETIME,
-                ) callconv(os.windows.WINAPI) void;
-            };
-
-            var ft: os.windows.FILETIME = undefined;
-            kernel32.GetSystemTimePreciseAsFileTime(&ft);
-            const ft64 = (@as(u64, ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
-
-            // FileTime is in units of 100 nanoseconds
-            // and uses the NTFS/Windows epoch of 1601-01-01 instead of Unix Epoch 1970-01-01.
-            const epoch_adjust = std.time.epoch.windows * (std.time.ns_per_s / 100);
-            return (@bitCast(i64, ft64) + epoch_adjust) * 100;
-        }
-
-        if (is_darwin) {
-            // macos has supported clock_gettime() since 10.12:
-            // https://opensource.apple.com/source/Libc/Libc-1158.1.2/gen/clock_gettime.3.auto.html
-        }
-
-        var ts: os.timespec = undefined;
-        os.clock_gettime(os.CLOCK.REALTIME, &ts) catch unreachable;
-        return @as(i64, ts.tv_sec) * std.time.ns_per_s + ts.tv_nsec;
-    }
-
-    pub fn tick(_: *Self) void {}
-};