tigerbeetle-node 0.9.0 → 0.10.0

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;
+};

package/src/tigerbeetle/src/c/tb_client/context.zig

@@ -0,0 +1,103 @@
+const std = @import("std");
+const ThreadType = @import("thread.zig").ThreadType;
+
+const api = @import("../tb_client.zig");
+const tb_status_t = api.tb_status_t;
+const tb_client_t = api.tb_client_t;
+const tb_completion_t = api.tb_completion_t;
+const tb_packet_t = api.tb_packet_t;
+const tb_packet_list_t = api.tb_packet_list_t;
+
+pub const ContextImplementation = struct {
+    submit_fn: fn (*ContextImplementation, *tb_packet_list_t) void,
+    deinit_fn: fn (*ContextImplementation) void,
+};
+
+pub fn ContextType(
+    comptime StateMachine: type,
+    comptime MessageBus: type,
+) type {
+    return struct {
+        const Context = @This();
+        const Thread = ThreadType(StateMachine, MessageBus);
+
+        allocator: std.mem.Allocator,
+        on_completion_ctx: usize,
+        on_completion_fn: tb_completion_t,
+        implementation: ContextImplementation,
+        thread: Thread,
+
+        pub fn init(
+            allocator: std.mem.Allocator,
+            out_tb_client: *tb_client_t,
+            out_packets: *tb_packet_list_t,
+            cluster_id: u32,
+            addresses_ptr: [*:0]const u8,
+            addresses_len: u32,
+            num_packets: u32,
+            on_completion_ctx: usize,
+            on_completion_fn: tb_completion_t,
+        ) tb_status_t {
+            const context = allocator.create(Context) catch return .out_of_memory;
+            context.allocator = allocator;
+            context.on_completion_ctx = on_completion_ctx;
+            context.on_completion_fn = on_completion_fn;
+
+            out_tb_client.* = api.context_to_client(&context.implementation);
+            context.implementation = .{
+                .submit_fn = Context.on_submit,
+                .deinit_fn = Context.on_deinit,
+            };
+
+            const addresses = @ptrCast([*]const u8, addresses_ptr)[0..addresses_len];
+            context.thread.init(
+                allocator,
+                cluster_id,
+                addresses,
+                num_packets,
+                Context.on_completion,
+            ) catch |err| {
+                allocator.destroy(context);
+                return switch (err) {
+                    error.Unexpected => .unexpected,
+                    error.OutOfMemory => .out_of_memory,
+                    error.InvalidAddress => .invalid_address,
+                    error.SystemResources => .system_resources,
+                    error.NetworkSubsystemFailed => .network_subsystem,
+                };
+            };
+
+            var list = tb_packet_list_t{};
+            for (context.thread.packets) |*packet| {
+                list.push(tb_packet_list_t.from(packet));
+            }
+
+            out_packets.* = list;
+            return .success;
+        }
+
+        fn on_submit(implementation: *ContextImplementation, packets: *tb_packet_list_t) void {
+            const context = @fieldParentPtr(Context, "implementation", implementation);
+            context.thread.submit(packets.*);
+        }
+
+        fn on_deinit(implementation: *ContextImplementation) void {
+            const context = @fieldParentPtr(Context, "implementation", implementation);
+            context.thread.deinit();
+            context.allocator.destroy(context);
+        }
+
+        fn on_completion(thread: *Thread, packet: *tb_packet_t, result: ?[]const u8) void {
+            const context = @fieldParentPtr(Context, "thread", thread);
+            const tb_client = api.context_to_client(&context.implementation);
+
+            context.on_completion_fn(
+                context.on_completion_ctx,
+                tb_client,
+                packet,
+                if (result) |r| r.ptr else null,
+                if (result) |r| @intCast(u32, r.len) else 0,
+            );
+        }
+    };
+}

package/src/tigerbeetle/src/c/tb_client/packet.zig

@@ -0,0 +1,80 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const Atomic = std.atomic.Atomic;
+
+pub const Packet = extern struct {
+    next: ?*Packet,
+    user_data: usize,
+    operation: u8,
+    status: Status,
+    data_size: u32,
+    data: [*]const u8,
+
+    pub const Status = enum(u8) {
+        ok,
+        too_much_data,
+        invalid_operation,
+        invalid_data_size,
+    };
+
+    pub const List = extern struct {
+        head: ?*Packet = null,
+        tail: ?*Packet = null,
+
+        pub fn from(packet: *Packet) List {
+            packet.next = null;
+            return List{
+                .head = packet,
+                .tail = packet,
+            };
+        }
+
+        pub fn push(self: *List, list: List) void {
+            const prev = if (self.tail) |tail| &tail.next else &self.head;
+            prev.* = list.head orelse return;
+            self.tail = list.tail orelse unreachable;
+        }
+
+        pub fn peek(self: List) ?*Packet {
+            return self.head orelse {
+                assert(self.tail == null);
+                return null;
+            };
+        }
+
+        pub fn pop(self: *List) ?*Packet {
+            const packet = self.head orelse return null;
+            self.head = packet.next;
+            if (self.head == null) self.tail = null;
+            return packet;
+        }
+    };
+
+    pub const Stack = struct {
+        pushed: Atomic(?*Packet) = Atomic(?*Packet).init(null),
+        popped: ?*Packet = null,
+
+        pub fn push(self: *Stack, list: List) void {
+            const head = list.head orelse return;
+            const tail = list.tail orelse unreachable;
+
+            var pushed = self.pushed.load(.Monotonic);
+            while (true) {
+                tail.next = pushed;
+                pushed = self.pushed.tryCompareAndSwap(
+                    pushed,
+                    head,
+                    .Release,
+                    .Monotonic,
+                ) orelse break;
+            }
+        }
+
+        pub fn pop(self: *Stack) ?*Packet {
+            if (self.popped == null) self.popped = self.pushed.swap(null, .Acquire);
+            const packet = self.popped orelse return null;
+            self.popped = packet.next;
+            return packet;
+        }
+    };
+};