tigerbeetle-node 0.8.0 → 0.10.0

package/src/tigerbeetle/src/benchmark.zig

@@ -9,8 +9,10 @@ pub const log_level: std.log.Level = .err;
 const cli = @import("cli.zig");
 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").StateMachine;
+const StateMachine = @import("state_machine.zig").StateMachineType(Storage);
 const RingBuffer = @import("ring_buffer.zig").RingBuffer;
 
 const vsr = @import("vsr.zig");
@@ -76,22 +78,28 @@ pub fn main() !void {
     var address = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", config.port)};
 
     var io = try IO.init(32, 0);
-    var message_bus = try MessageBus.init(allocator, cluster_id, address[0..], client_id, &io);
-    defer message_bus.deinit();
+    defer io.deinit();
+
+    var message_pool = try MessagePool.init(allocator, .client);
+    defer message_pool.deinit(allocator);
 
     var client = try Client.init(
         allocator,
         client_id,
         cluster_id,
         @intCast(u8, address.len),
-        &message_bus,
+        &message_pool,
+        .{
+            .configuration = address[0..],
+            .io = &io,
+        },
     );
-    defer client.deinit();
-
-    message_bus.set_on_message(*Client, &client, Client.on_message);
+    defer client.deinit(allocator);
 
     // Pre-allocate a million transfers:
-    const transfers = try arena.allocator().alloc(tb.Transfer, transfers_max);
+    const transfers = try allocator.alloc(tb.Transfer, transfers_max);
+    defer allocator.free(transfers);
+    
     for (transfers) |*transfer, index| {
         transfer.* = .{
             .id = index,
@@ -158,7 +166,7 @@ const TimedQueue = struct {
     transfers_latency_max: i64,
     client: *Client,
     io: *IO,
-    batches: RingBuffer(Batch, batches_count),
+    batches: RingBuffer(Batch, batches_count, .array),
 
     pub fn init(client: *Client, io: *IO) TimedQueue {
         var self = TimedQueue{

package/src/tigerbeetle/src/benchmark_array_search.zig

@@ -0,0 +1,317 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const math = std.math;
+
+const binary_search = @import("./binary_search.zig").binary_search;
+const eytzinger = @import("./eytzinger.zig").eytzinger;
+const perf = @import("./benchmarks/perf.zig");
+
+const GiB = 1 << 30;
+const searches = 500_000;
+
+const kv_types = .{
+    .{ .key_size = 8, .value_size = 128 },
+    .{ .key_size = 8, .value_size = 64 },
+    .{ .key_size = 16, .value_size = 16 },
+    .{ .key_size = 32, .value_size = 32 },
+};
+
+// keys_per_summary = values_per_page / summary_fraction
+const summary_fractions = .{ 4, 8, 16, 32 };
+const values_per_page = .{ 128, 256, 512, 1024, 2048, 4096, 8192 };
+const body_fmt = "{:_>2}B/{:_>3}B {:_>4}/{:_>4} {s}{s}: WT={:_>6}ns UT={:_>6}ns" ++
+    " CY={:_>6} IN={:_>6} CR={:_>5} CM={:_>5} BM={}\n";
+
+const summary_sizes = blk: {
+    var sizes: [values_per_page.len][summary_fractions.len]usize = undefined;
+    for (values_per_page) |values_count, v| {
+        for (summary_fractions) |fraction, k| {
+            // Set in reverse order so that the summary sizes ascend.
+            sizes[v][summary_fractions.len - k - 1] = values_count / fraction;
+        }
+    }
+    break :blk sizes;
+};
+
+pub fn main() !void {
+    std.log.info("Samples: {}", .{searches});
+    std.log.info("WT: Wall time/search", .{});
+    std.log.info("UT: utime time/search", .{});
+    std.log.info("CY: CPU cycles/search", .{});
+    std.log.info("IN: instructions/search", .{});
+    std.log.info("CR: cache references/search", .{});
+    std.log.info("CM: cache misses/search", .{});
+    std.log.info("BM: branch misses/search", .{});
+
+    var seed: u64 = undefined;
+    try std.os.getrandom(std.mem.asBytes(&seed));
+    var prng = std.rand.DefaultPrng.init(seed);
+
+    // Allocate on the heap just once.
+    // All page allocations reuse this buffer to speed up the run time.
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+
+    const blob_size = GiB;
+    var blob = try arena.allocator.alloc(u8, blob_size);
+
+    inline for (kv_types) |kv| {
+        inline for (values_per_page) |values_count, v| {
+            inline for (summary_sizes[v]) |keys_count| {
+                try run_benchmark(.{
+                    .blob_size = blob_size,
+                    .key_size = kv.key_size,
+                    .value_size = kv.value_size,
+                    .keys_count = keys_count,
+                    .values_count = values_count,
+                    .searches = searches,
+                }, blob, &prng.random);
+            }
+        }
+    }
+}
+
+fn run_benchmark(comptime layout: Layout, blob: []u8, random: *std.rand.Random) !void {
+    assert(blob.len == layout.blob_size);
+    const Eytzinger = eytzinger(layout.keys_count - 1, layout.values_count);
+    const V = Value(layout);
+    const K = V.Key;
+    const Page = struct {
+        keys: [layout.keys_count]K,
+        values: [layout.values_count]V,
+    };
+    const page_count = layout.blob_size / @sizeOf(Page);
+
+    // Search pages and keys in random order.
+    var page_picker = shuffled_index(page_count, random);
+    var value_picker = shuffled_index(layout.values_count, random);
+
+    // Generate 1GiB worth of 24KiB pages.
+    var blob_alloc = std.heap.FixedBufferAllocator.init(blob);
+    var pages = try blob_alloc.allocator.alloc(Page, page_count);
+    random.bytes(std.mem.sliceAsBytes(pages));
+    for (pages) |*page| {
+        for (page.values) |*value, i| value.key = i;
+        Eytzinger.layout_from_keys_or_values(K, V, V.key_from_value, V.max_key, &page.values, &page.keys);
+    }
+
+    const stdout = std.io.getStdOut().writer();
+    {
+        var benchmark = try Benchmark.begin();
+        var i: usize = 0;
+        var v: usize = 0;
+        while (i < layout.searches) : (i += 1) {
+            const page_index = page_picker[i % page_picker.len];
+            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)];
+
+            assert(hit.key == target);
+            if (i % pages.len == 0) v += 1;
+        }
+
+        const result = try benchmark.end(layout.searches);
+        try stdout.print(body_fmt, .{
+            layout.key_size,
+            layout.value_size,
+            layout.keys_count,
+            layout.values_count,
+            "E",
+            "B",
+            result.wall_time,
+            result.utime,
+            result.cpu_cycles,
+            result.instructions,
+            result.cache_references,
+            result.cache_misses,
+            result.branch_misses,
+        });
+    }
+
+    {
+        var benchmark = try Benchmark.begin();
+        var i: usize = 0;
+        var v: usize = 0;
+        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)];
+
+            assert(hit.key == target);
+            if (i % pages.len == 0) v += 1;
+        }
+        const result = try benchmark.end(layout.searches);
+        try stdout.print(body_fmt, .{
+            layout.key_size,
+            layout.value_size,
+            layout.keys_count,
+            layout.values_count,
+            "_",
+            "B",
+            result.wall_time,
+            result.utime,
+            result.cpu_cycles,
+            result.instructions,
+            result.cache_references,
+            result.cache_misses,
+            result.branch_misses,
+        });
+    }
+}
+
+const Layout = struct {
+    blob_size: usize, // bytes allocated for all pages
+    key_size: usize, // bytes per key
+    value_size: usize, // bytes per value
+    keys_count: usize, // keys per page (in the summary)
+    values_count: usize, // values per page
+    searches: usize,
+};
+
+fn Value(comptime layout: Layout) type {
+    return struct {
+        pub const max_key = 1 << (8 * layout.key_size) - 1;
+        pub const Key = math.IntFittingRange(0, max_key);
+        const Self = @This();
+        key: Key,
+        body: [layout.value_size - layout.key_size]u8,
+
+        comptime {
+            assert(@sizeOf(Key) == layout.key_size);
+            assert(@sizeOf(Self) == layout.value_size);
+        }
+
+        inline fn key_from_value(self: Self) Key {
+            return self.key;
+        }
+
+        inline fn key_from_key(x: Key) Key {
+            return x;
+        }
+
+        inline fn key_compare(a: Key, b: Key) math.Order {
+            return math.order(a, b);
+        }
+    };
+}
+
+const BenchmarkResult = struct {
+    wall_time: u64, // nanoseconds
+    utime: u64, // nanoseconds
+    cpu_cycles: usize,
+    instructions: usize,
+    cache_references: usize,
+    cache_misses: usize,
+    branch_misses: usize,
+};
+
+const PERF = perf.PERF;
+const perf_event_attr = perf.perf_event_attr;
+const perf_event_open = perf.perf_event_open;
+const perf_counters = [_]PERF.COUNT.HW{
+    PERF.COUNT.HW.CPU_CYCLES,
+    PERF.COUNT.HW.INSTRUCTIONS,
+    PERF.COUNT.HW.CACHE_REFERENCES,
+    PERF.COUNT.HW.CACHE_MISSES,
+    PERF.COUNT.HW.BRANCH_MISSES,
+};
+
+const Benchmark = struct {
+    timer: std.time.Timer,
+    rusage: std.os.rusage,
+    perf_fds: [perf_counters.len]std.os.fd_t,
+
+    fn begin() !Benchmark {
+        const flags = PERF.FLAG.FD_NO_GROUP;
+        var perf_fds = [1]std.os.fd_t{-1} ** perf_counters.len;
+        for (perf_counters) |counter, i| {
+            var attr: perf_event_attr = .{
+                .type = PERF.TYPE.HARDWARE,
+                .config = @enumToInt(counter),
+                .flags = .{
+                    .disabled = true,
+                    .exclude_kernel = true,
+                    .exclude_hv = true,
+                },
+            };
+            perf_fds[i] = try perf_event_open(&attr, 0, -1, perf_fds[0], PERF.FLAG.FD_CLOEXEC);
+        }
+        const err = std.os.linux.ioctl(perf_fds[0], PERF.EVENT_IOC.ENABLE, PERF.IOC_FLAG_GROUP);
+        if (err == -1) return error.Unexpected;
+
+        // Start the wall clock after perf, since setup is slow.
+        const timer = try std.time.Timer.start();
+        return Benchmark{
+            .timer = timer,
+            // TODO pass std.os.linux.rusage.SELF once Zig is upgraded
+            .rusage = std.os.getrusage(0),
+            .perf_fds = perf_fds,
+        };
+    }
+
+    fn end(self: *Benchmark, samples: usize) !BenchmarkResult {
+        defer {
+            for (perf_counters) |_, i| {
+                std.os.close(self.perf_fds[i]);
+                self.perf_fds[i] = -1;
+            }
+        }
+
+        const rusage = std.os.getrusage(0);
+        const err = std.os.linux.ioctl(self.perf_fds[0], PERF.EVENT_IOC.DISABLE, PERF.IOC_FLAG_GROUP);
+        if (err == -1) return error.Unexpected;
+        return BenchmarkResult{
+            .wall_time = self.timer.read() / samples,
+            .utime = (timeval_to_ns(rusage.utime) - timeval_to_ns(self.rusage.utime)) / samples,
+            .cpu_cycles = (try readPerfFd(self.perf_fds[0])) / samples,
+            .instructions = (try readPerfFd(self.perf_fds[1])) / samples,
+            .cache_references = (try readPerfFd(self.perf_fds[2])) / samples,
+            .cache_misses = (try readPerfFd(self.perf_fds[3])) / samples,
+            .branch_misses = (try readPerfFd(self.perf_fds[4])) / samples,
+        };
+    }
+};
+
+// shuffle([0,1,…,n-1])
+fn shuffled_index(comptime n: usize, rand: *std.rand.Random) [n]usize {
+    var indices: [n]usize = undefined;
+    for (indices) |*i, j| i.* = j;
+    rand.shuffle(usize, indices[0..]);
+    return indices;
+}
+
+fn timeval_to_ns(tv: std.os.timeval) u64 {
+    const ns_per_us = std.time.ns_per_s / std.time.us_per_s;
+    return @bitCast(u64, tv.tv_sec) * std.time.ns_per_s +
+        @bitCast(u64, tv.tv_usec) * ns_per_us;
+}
+
+fn readPerfFd(fd: std.os.fd_t) !usize {
+    var result: usize = 0;
+    const n = try std.os.read(fd, std.mem.asBytes(&result));
+    assert(n == @sizeOf(usize));
+
+    return result;
+}
+
+fn binary_search_keys(
+    comptime layout: Layout,
+    comptime Key: type,
+    comptime V: type,
+    comptime compare_keys: fn (Key, Key) math.Order,
+    keys: []const Key,
+    values: []const V,
+    key: Key,
+) []const V {
+    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_stride = layout.values_count / layout.keys_count;
+    const high = key_index * key_stride;
+    if (key_index < keys.len and keys[key_index] == key) {
+        return if (high == 0) values[0..1] else values[high - 1 .. high];
+    }
+    return values[high - key_stride .. high];
+}

package/src/tigerbeetle/src/benchmarks/perf.zig

@@ -0,0 +1,299 @@
+// Copyright (c) 2015-2021, Zig contributors
+// Backported from https://github.com/ziglang/zig/blob/master/lib/std/os/linux.zig
+// TODO Remove this file once we upgrade to Zig 0.9.0.
+const std = @import("std");
+const pid_t = std.os.linux.pid_t;
+const fd_t = std.os.linux.fd_t;
+
+pub fn perf_event_open(
+    attr: *perf_event_attr,
+    pid: pid_t,
+    cpu: i32,
+    group_fd: fd_t,
+    flags: usize,
+) !fd_t {
+    const rc = perf_event_open_internal(attr, pid, cpu, group_fd, flags);
+    const errno = std.os.errno(rc);
+    if (errno != 0) {
+        std.log.err("perf_event_open_internal errno={}", .{errno});
+        return error.Unexpected;
+    }
+    return @intCast(fd_t, rc);
+}
+
+fn perf_event_open_internal(
+    attr: *perf_event_attr,
+    pid: pid_t,
+    cpu: i32,
+    group_fd: fd_t,
+    flags: usize,
+) usize {
+    return std.os.linux.syscall5(
+        .perf_event_open,
+        @ptrToInt(attr),
+        @bitCast(usize, @as(isize, pid)),
+        @bitCast(usize, @as(isize, cpu)),
+        @bitCast(usize, @as(isize, group_fd)),
+        flags,
+    );
+}
+
+pub const perf_event_attr = extern struct {
+    /// Major type: hardware/software/tracepoint/etc.
+    type: PERF.TYPE = undefined,
+    /// Size of the attr structure, for fwd/bwd compat.
+    size: u32 = @sizeOf(perf_event_attr),
+    /// Type specific configuration information.
+    config: u64 = 0,
+
+    sample_period_or_freq: u64 = 0,
+    sample_type: u64 = 0,
+    read_format: u64 = 0,
+
+    flags: packed struct {
+        /// off by default
+        disabled: bool = false,
+        /// children inherit it
+        inherit: bool = false,
+        /// must always be on PMU
+        pinned: bool = false,
+        /// only group on PMU
+        exclusive: bool = false,
+        /// don't count user
+        exclude_user: bool = false,
+        /// ditto kernel
+        exclude_kernel: bool = false,
+        /// ditto hypervisor
+        exclude_hv: bool = false,
+        /// don't count when idle
+        exclude_idle: bool = false,
+        /// include mmap data
+        mmap: bool = false,
+        /// include comm data
+        comm: bool = false,
+        /// use freq, not period
+        freq: bool = false,
+        /// per task counts
+        inherit_stat: bool = false,
+        /// next exec enables
+        enable_on_exec: bool = false,
+        /// trace fork/exit
+        task: bool = false,
+        /// wakeup_watermark
+        watermark: bool = false,
+        /// precise_ip:
+        ///
+        ///  0 - SAMPLE_IP can have arbitrary skid
+        ///  1 - SAMPLE_IP must have constant skid
+        ///  2 - SAMPLE_IP requested to have 0 skid
+        ///  3 - SAMPLE_IP must have 0 skid
+        ///
+        ///  See also PERF_RECORD_MISC_EXACT_IP
+        /// skid constraint
+        precise_ip: u2 = 0,
+        /// non-exec mmap data
+        mmap_data: bool = false,
+        /// sample_type all events
+        sample_id_all: bool = false,
+
+        /// don't count in host
+        exclude_host: bool = false,
+        /// don't count in guest
+        exclude_guest: bool = false,
+
+        /// exclude kernel callchains
+        exclude_callchain_kernel: bool = false,
+        /// exclude user callchains
+        exclude_callchain_user: bool = false,
+        /// include mmap with inode data
+        mmap2: bool = false,
+        /// flag comm events that are due to an exec
+        comm_exec: bool = false,
+        /// use @clockid for time fields
+        use_clockid: bool = false,
+        /// context switch data
+        context_switch: bool = false,
+        /// Write ring buffer from end to beginning
+        write_backward: bool = false,
+        /// include namespaces data
+        namespaces: bool = false,
+
+        __reserved_1: u35 = 0,
+    } = .{},
+    /// wakeup every n events, or
+    /// bytes before wakeup
+    wakeup_events_or_watermark: u32 = 0,
+
+    bp_type: u32 = 0,
+
+    /// This field is also used for:
+    /// bp_addr
+    /// kprobe_func for perf_kprobe
+    /// uprobe_path for perf_uprobe
+    config1: u64 = 0,
+    /// This field is also used for:
+    /// bp_len
+    /// kprobe_addr when kprobe_func == null
+    /// probe_offset for perf_[k,u]probe
+    config2: u64 = 0,
+
+    /// enum perf_branch_sample_type
+    branch_sample_type: u64 = 0,
+
+    /// Defines set of user regs to dump on samples.
+    /// See asm/perf_regs.h for details.
+    sample_regs_user: u64 = 0,
+
+    /// Defines size of the user stack to dump on samples.
+    sample_stack_user: u32 = 0,
+
+    clockid: i32 = 0,
+    /// Defines set of regs to dump for each sample
+    /// state captured on:
+    ///  - precise = 0: PMU interrupt
+    ///  - precise > 0: sampled instruction
+    ///
+    /// See asm/perf_regs.h for details.
+    sample_regs_intr: u64 = 0,
+
+    /// Wakeup watermark for AUX area
+    aux_watermark: u32 = 0,
+    sample_max_stack: u16 = 0,
+    /// Align to u64
+    __reserved_2: u16 = 0,
+};
+
+pub const PERF = struct {
+    pub const TYPE = enum(u32) {
+        HARDWARE,
+        SOFTWARE,
+        TRACEPOINT,
+        HW_CACHE,
+        RAW,
+        BREAKPOINT,
+        MAX,
+    };
+
+    pub const COUNT = struct {
+        pub const HW = enum(u32) {
+            CPU_CYCLES,
+            INSTRUCTIONS,
+            CACHE_REFERENCES,
+            CACHE_MISSES,
+            BRANCH_INSTRUCTIONS,
+            BRANCH_MISSES,
+            BUS_CYCLES,
+            STALLED_CYCLES_FRONTEND,
+            STALLED_CYCLES_BACKEND,
+            REF_CPU_CYCLES,
+            MAX,
+
+            pub const CACHE = enum(u32) {
+                L1D,
+                L1I,
+                LL,
+                DTLB,
+                ITLB,
+                BPU,
+                NODE,
+                MAX,
+
+                pub const OP = enum(u32) {
+                    READ,
+                    WRITE,
+                    PREFETCH,
+                    MAX,
+                };
+
+                pub const RESULT = enum(u32) {
+                    ACCESS,
+                    MISS,
+                    MAX,
+                };
+            };
+        };
+
+        pub const SW = enum(u32) {
+            CPU_CLOCK,
+            TASK_CLOCK,
+            PAGE_FAULTS,
+            CONTEXT_SWITCHES,
+            CPU_MIGRATIONS,
+            PAGE_FAULTS_MIN,
+            PAGE_FAULTS_MAJ,
+            ALIGNMENT_FAULTS,
+            EMULATION_FAULTS,
+            DUMMY,
+            BPF_OUTPUT,
+            MAX,
+        };
+    };
+
+    pub const SAMPLE = struct {
+        pub const IP = 1;
+        pub const TID = 2;
+        pub const TIME = 4;
+        pub const ADDR = 8;
+        pub const READ = 16;
+        pub const CALLCHAIN = 32;
+        pub const ID = 64;
+        pub const CPU = 128;
+        pub const PERIOD = 256;
+        pub const STREAM_ID = 512;
+        pub const RAW = 1024;
+        pub const BRANCH_STACK = 2048;
+        pub const REGS_USER = 4096;
+        pub const STACK_USER = 8192;
+        pub const WEIGHT = 16384;
+        pub const DATA_SRC = 32768;
+        pub const IDENTIFIER = 65536;
+        pub const TRANSACTION = 131072;
+        pub const REGS_INTR = 262144;
+        pub const PHYS_ADDR = 524288;
+        pub const MAX = 1048576;
+
+        pub const BRANCH = struct {
+            pub const USER = 1 << 0;
+            pub const KERNEL = 1 << 1;
+            pub const HV = 1 << 2;
+            pub const ANY = 1 << 3;
+            pub const ANY_CALL = 1 << 4;
+            pub const ANY_RETURN = 1 << 5;
+            pub const IND_CALL = 1 << 6;
+            pub const ABORT_TX = 1 << 7;
+            pub const IN_TX = 1 << 8;
+            pub const NO_TX = 1 << 9;
+            pub const COND = 1 << 10;
+            pub const CALL_STACK = 1 << 11;
+            pub const IND_JUMP = 1 << 12;
+            pub const CALL = 1 << 13;
+            pub const NO_FLAGS = 1 << 14;
+            pub const NO_CYCLES = 1 << 15;
+            pub const TYPE_SAVE = 1 << 16;
+            pub const MAX = 1 << 17;
+        };
+    };
+
+    pub const FLAG = struct {
+        pub const FD_NO_GROUP = 1 << 0;
+        pub const FD_OUTPUT = 1 << 1;
+        pub const PID_CGROUP = 1 << 2;
+        pub const FD_CLOEXEC = 1 << 3;
+    };
+
+    pub const EVENT_IOC = struct {
+        pub const ENABLE = 9216;
+        pub const DISABLE = 9217;
+        pub const REFRESH = 9218;
+        pub const RESET = 9219;
+        pub const PERIOD = 1074275332;
+        pub const SET_OUTPUT = 9221;
+        pub const SET_FILTER = 1074275334;
+        pub const SET_BPF = 1074013192;
+        pub const PAUSE_OUTPUT = 1074013193;
+        pub const QUERY_BPF = 3221758986;
+        pub const MODIFY_ATTRIBUTES = 1074275339;
+    };
+
+    pub const IOC_FLAG_GROUP = 1;
+};