tigerbeetle 0.0.40 → 0.17.8

data/ext/tb_client/tigerbeetle/src/stdx/huge_page_allocator.zig

@@ -1,115 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const stdx = @import("stdx.zig");
-const Allocator = std.mem.Allocator;
-
-const log = std.log.scoped(.allocator);
-
-const page_allocator_vtable = std.heap.page_allocator.vtable;
-
-/// Like `std.heap.page_allocator`, but on Linux applies `MADV_HUGEPAGE` to
-/// allocated regions so that the kernel may back them with 2 MiB transparent
-/// huge pages, reducing TLB pressure for large allocations.
-///
-/// Only `alloc` is intercepted. `resize` and `remap` inherit the VMA flags
-/// (including `VM_HUGEPAGE`) set on the original mapping, so they need no
-/// additional `madvise` call.
-///
-/// On non-Linux targets this is identical to `std.heap.page_allocator`.
-pub const huge_page_allocator: Allocator = .{
-    .ptr = std.heap.page_allocator.ptr,
-    .vtable = if (builtin.target.os.tag == .linux) &vtable else page_allocator_vtable,
-};
-
-const vtable: Allocator.VTable = .{
-    .alloc = alloc,
-    .resize = page_allocator_vtable.resize,
-    .remap = page_allocator_vtable.remap,
-    .free = page_allocator_vtable.free,
-};
-
-fn alloc(context: *anyopaque, n: usize, alignment: std.mem.Alignment, ra: usize) ?[*]u8 {
-    const ptr = page_allocator_vtable.alloc(context, n, alignment, ra) orelse return null;
-    // This is just a hint, so if it fails we can safely ignore it.
-    std.posix.madvise(@alignCast(ptr), n, std.posix.MADV.HUGEPAGE) catch {
-        log.warn("Transparent Huge Pages (THP) are disabled.", .{});
-    };
-    return ptr;
-}
-
-const testing = std.testing;
-const assert = std.debug.assert;
-
-/// Checks /proc/self/smaps for the "hg" VmFlag on the mapping containing `ptr`.
-fn verify_address_is_huge_page(ptr: [*]const u8) !bool {
-    assert(builtin.target.os.tag == .linux);
-    const addr = @intFromPtr(ptr);
-
-    var file = try std.fs.openFileAbsolute("/proc/self/smaps", .{});
-    defer file.close();
-
-    const content = try file.readToEndAlloc(testing.allocator, 10 * 1024 * 1024);
-    defer testing.allocator.free(content);
-
-    var lines = std.mem.splitScalar(u8, content, '\n');
-
-    // Find the mapping header that contains our address.
-    while (lines.next()) |line| {
-        if (parse_mapping_range(line)) |range| {
-            if (addr >= range.min and addr < range.max) {
-                // Scan subsequent lines for VmFlags within this mapping.
-                while (lines.next()) |detail| {
-                    if (stdx.cut_prefix(detail, "VmFlags:")) |rest| {
-                        return stdx.cut(rest, "hg") != null;
-                    }
-                }
-            }
-        }
-    }
-    return false;
-}
-
-fn parse_mapping_range(line: []const u8) ?struct { min: u64, max: u64 } {
-    const addr_range, _ = stdx.cut(line, " ") orelse return null;
-    const addr_hex_min, const addr_hex_max = stdx.cut(addr_range, "-") orelse return null;
-    const addr_min = std.fmt.parseUnsigned(u64, addr_hex_min, 16) catch return null;
-    const addr_max = std.fmt.parseUnsigned(u64, addr_hex_max, 16) catch return null;
-    return .{ .min = addr_min, .max = addr_max };
-}
-
-test "huge_page_allocator: basic alloc and free" {
-    const slice = try huge_page_allocator.alloc(u8, 4096);
-    defer huge_page_allocator.free(slice);
-
-    @memset(slice, 0xab);
-    try testing.expectEqual(@as(u8, 0xab), slice[0]);
-}
-
-test "huge_page_allocator: large THP-eligible allocation" {
-    // 4 MiB — large enough for THP promotion on Linux.
-    const size = 4 * 1024 * 1024;
-    const slice = try huge_page_allocator.alloc(u8, size);
-    defer huge_page_allocator.free(slice);
-
-    @memset(slice, 0xcd);
-    try testing.expectEqual(@as(u8, 0xcd), slice[size - 1]);
-
-    if (builtin.target.os.tag == .linux) {
-        // Verify that MADV_HUGEPAGE was applied by checking VmFlags in /proc/self/smaps.
-        // The "hg" flag means the process requested hugepages via madvise — this is
-        // deterministic regardless of whether the kernel actually promoted the pages.
-        try testing.expect(try verify_address_is_huge_page(slice.ptr));
-    }
-}
-
-test "huge_page_allocator: as ArenaAllocator backing" {
-    var arena = std.heap.ArenaAllocator.init(huge_page_allocator);
-    defer arena.deinit();
-
-    const alloc1 = try arena.allocator().alloc(u8, 1024);
-    const alloc2 = try arena.allocator().alloc(u8, 2048);
-    @memset(alloc1, 1);
-    @memset(alloc2, 2);
-    try testing.expectEqual(@as(u8, 1), alloc1[0]);
-    try testing.expectEqual(@as(u8, 2), alloc2[0]);
-}

data/ext/tb_client/tigerbeetle/src/stdx/mlock.zig

@@ -1,92 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-const os = std.os;
-
-const stdx = @import("stdx.zig");
-
-const MiB = stdx.MiB;
-
-const log = std.log.scoped(.mlock);
-
-const MemoryLockError = error{memory_not_locked} || std.posix.UnexpectedError;
-
-const mlockall_error = "Unable to lock pages in memory ({s})" ++
-    " - kernel swap would otherwise bypass TigerBeetle's storage fault tolerance. ";
-
-/// Pin virtual memory pages allocated so far to physical pages in RAM, preventing the pages from
-/// being swapped out and introducing storage error into memory, bypassing ECC RAM.
-pub fn memory_lock_allocated(options: struct { allocated_size: usize }) MemoryLockError!void {
-    switch (builtin.os.tag) {
-        .linux => try memory_lock_allocated_linux(),
-        .macos => {
-            // macOS has mlock() but not mlockall(). mlock() requires an address range which
-            // would be difficult to gather for non-heap memory that is also faulted in,
-            // such as the stack, globals, etc.
-        },
-        .windows => try memory_lock_allocated_windows(options.allocated_size),
-        else => @compileError("unsupported platform"),
-    }
-}
-
-fn memory_lock_allocated_linux() MemoryLockError!void {
-    // https://github.com/torvalds/linux/blob/v6.12/include/uapi/asm-generic/mman.h#L18-L20
-    const MCL_CURRENT = 1; // Lock all currently mapped pages.
-    const MCL_ONFAULT = 4; // Lock all pages faulted in (i.e. stack space).
-    const result = os.linux.syscall1(.mlockall, MCL_CURRENT | MCL_ONFAULT);
-    switch (os.linux.E.init(result)) {
-        .SUCCESS => return,
-        .AGAIN => log.warn(mlockall_error, .{"some addresses could not be locked"}),
-        .NOMEM => log.warn(mlockall_error, .{"memory would exceed RLIMIT_MEMLOCK"}),
-        .PERM => log.warn(mlockall_error, .{
-            "insufficient privileges to lock memory",
-        }),
-        .INVAL => unreachable, // MCL_ONFAULT specified without MCL_CURRENT.
-        else => |err| return stdx.unexpected_errno("mlockall", err),
-    }
-    return error.memory_not_locked;
-}
-
-fn memory_lock_allocated_windows(allocated_size: usize) MemoryLockError!void {
-    // Windows has VirtualLock which works similar to mlock with an address range.
-    // It would be difficult to gather the addresses of non-heap memory that is also
-    // faulted in, such as the stack, globals, etc. SetProcessWorkingSetSize can be
-    // used instead to lock all existing pages into memory to avoid swapping.
-    const process_handle = os.windows.kernel32.GetCurrentProcess();
-    var working_set_min: os.windows.SIZE_T = 0;
-    var working_set_max: os.windows.SIZE_T = 0;
-
-    if (stdx.windows.GetProcessWorkingSetSize(
-        process_handle,
-        &working_set_min,
-        &working_set_max,
-    ) == os.windows.FALSE) {
-        working_set_min = allocated_size; // Count bytes allocated so far.
-        working_set_min += 64 * MiB; // 64mb buffer room for stack/globals.
-        working_set_max = working_set_min * 2; // Buffer room for new page faults.
-    }
-
-    if (stdx.windows.SetProcessWorkingSetSize(
-        process_handle,
-        working_set_min,
-        working_set_max,
-    ) == os.windows.FALSE) {
-        // From std.os.windows.unexpectedError():
-        const format_flags = os.windows.FORMAT_MESSAGE_FROM_SYSTEM |
-            os.windows.FORMAT_MESSAGE_IGNORE_INSERTS;
-
-        // 614 is the length of the longest windows error description.
-        var buffer: [614:0]os.windows.WCHAR = undefined;
-        const buffer_size = os.windows.kernel32.FormatMessageW(
-            format_flags,
-            null,
-            os.windows.kernel32.GetLastError(),
-            os.windows.LANG.NEUTRAL | (os.windows.SUBLANG.DEFAULT << 10),
-            &buffer,
-            buffer.len,
-            null,
-        );
-
-        log.warn(mlockall_error, .{std.unicode.fmtUtf16Le(buffer[0..buffer_size])});
-        return error.memory_not_locked;
-    }
-}