diff options
| author | Gabriel Schneider <[email protected]> | 2026-10-30 17:35:06 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-10-30 17:35:06 -0300 |
| commit | 6d8da8721141284cf33bb901168b26135893eb86 (patch) | |
| tree | 791d63401d4e85fbca1d597a8ce0326e70efd545 /src/memory.zig | |
| parent | efd43a3a2cf03bb741366331158b368abf9ac583 (diff) | |
| parent | bf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff) | |
| download | pardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz pardes-6d8da8721141284cf33bb901168b26135893eb86.zip | |
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'src/memory.zig')
| -rw-r--r-- | src/memory.zig | 543 |
1 files changed, 474 insertions, 69 deletions
diff --git a/src/memory.zig b/src/memory.zig index f30e4392..cb75ee0e 100644 --- a/src/memory.zig +++ b/src/memory.zig @@ -16,24 +16,58 @@ pub const limits = struct { pub const pending_write_cap: usize = if (board) 0 else 4 * MiB; pub const wrap_rows = if (board) 128 else 256; pub const undo_max = if (board) 16 else 256; + /// The text a file's undo and redo steps hold together, kept by dropping + /// the oldest; the newest step always stays, so the bound per file is + /// this plus one snapshot (at most max_file_bytes). + pub const undo_bytes: usize = if (board) 64 * KiB else 64 * MiB; pub const message_log = if (board) 16 else 128; + /// ranges one selection holds; helix has no limit, and a `%s` over a + /// file's words wants hundreds + pub const selections = if (board) 64 else 1024; + /// /log's ring, which records whether or not anyone reads it. + pub const log_bytes: usize = if (board) 4 * KiB else 64 * KiB; pub const max_tag_tail: usize = if (board) 512 else 4096; + /// Pixels one image may decode to (RGBA, 4 bytes each): checked from its + /// header before stb_image allocates them. + pub const image_decode_pixels: usize = if (board) 0 else 64 * 1024 * 1024; + /// What the core's per-step scratch arena and the frame arena keep + /// between steps: a step that needed more (a huge Callstack's sources) + /// gives the rest back instead of holding its high-water mark. + pub const scratch_kept: usize = if (board) 4 * KiB else 16 * MiB; + pub const frame_kept: usize = if (board) 4 * KiB else 16 * MiB; + /// The other open files one language query copies for its server, in + /// bytes: past it the rest are left out (the asked file always goes). + pub const lsp_snapshot_bytes: usize = if (board) 0 else 64 * MiB; + /// One paste, from any shell: past it, the rest is left out and said. + pub const max_paste_bytes: usize = if (board) 16 * KiB else 4 * MiB; pub const host_path_cap: usize = if (board) 0 else 4095; /// -Dembed-sources: the editor serves its own sources under /src. pub const embedded_sources = config.embed_sources; pub const hexdump_row_bytes: u32 = if (board) 8 else 16; + /// Each arena's fixed region. On a native target these are address + /// space reserved at startup, resident only where used (`Pages`), so + /// they are sized for the worst case: the core holds a 256 MiB file, its + /// edit's copy and its undo. pub const arena = struct { - pub const pardes = if (board) 4 * KiB else if (reduced_target) 8 * MiB else 32 * MiB; - pub const frame = if (board) 4 * KiB else if (reduced_target) 4 * MiB else 16 * MiB; - pub const tree_sitter = if (board) 0 else if (reduced_target) 4 * MiB else 16 * MiB; - pub const image = if (board) 0 else if (reduced_target) 64 * KiB else 32 * MiB; - pub const pdf = if (board) 0 else if (reduced_target or !config.mupdf) 64 * KiB else 64 * MiB; + pub const pardes = if (board) 4 * KiB else if (reduced_target) 8 * MiB else 1024 * MiB; + pub const frame = if (board) 4 * KiB else if (reduced_target) 4 * MiB else 64 * MiB; + pub const lsp = if (board or reduced_target) 0 else 512 * MiB; + /// What a native shell allocates itself (`host`): its screen, the + /// bytes its ptys read, its 9P connections, its pipe jobs. + pub const host = if (board or reduced_target) 0 else 512 * MiB; + pub const tree_sitter = if (board) 0 else if (reduced_target) 4 * MiB else 256 * MiB; + pub const image = if (board) 0 else if (reduced_target) 64 * KiB else 256 * MiB; + pub const pdf = if (board) 0 else if (reduced_target or !config.mupdf) 64 * KiB else 512 * MiB; + /// One language query's working memory (its parsed answers, the rows + /// it writes): a hard bound, nothing spills. Callstack walks until it + /// would leave less than its rendering reserve. + pub const lsp_query = if (board or reduced_target) 0 else 256 * MiB; }; }; const Allocator = std.mem.Allocator; -const debug_enabled = builtin.mode == .Debug; +const debug_enabled = builtin.mode == .debug; pub const Allocators = struct { pardes: Allocator, @@ -44,81 +78,436 @@ pub const Allocators = struct { pdf: Allocator, }; -var pardes_fallback: std.heap.StackFallbackAllocator(limits.arena.pardes) = undefined; -var frame_fallback: std.heap.StackFallbackAllocator(limits.arena.frame) = undefined; -var tree_sitter_fallback: std.heap.StackFallbackAllocator(limits.arena.tree_sitter) = undefined; -var image_fallback: std.heap.StackFallbackAllocator(limits.arena.image) = undefined; -var pdf_fallback: std.heap.StackFallbackAllocator(limits.arena.pdf) = undefined; +/// A freestanding target's arena (web, board): `std.heap.StackFallbackAllocator` +/// with the buffer taken through its lock-free interface. A +/// FixedBufferAllocator frees only its last block, so once a big operation +/// fills the buffer everything after spills; a native target uses `Pages`. The core's allocator is used from two threads: a 9P +/// connection task answers a request while the editor's own thread is out +/// in a syscall that allocates (`readFileLimit`, `grep`; see `pardes.turn`). +/// The buffer is a separate zeroed global, not a field: an `undefined` one is +/// written into a Debug binary as 0xAA filler, 160 MB of file for the five +/// arenas, where a zeroed one is .bss and costs nothing. +const SharedStackFallback = struct { + buffer: []u8, + fallback_allocator: Allocator = undefined, + fixed: std.heap.FixedBufferAllocator = undefined, -const Debug = std.heap.DebugAllocator(.{}); -var pardes_debug: Debug = .init; -var frame_debug: Debug = .init; -var lsp_debug: Debug = .init; -var tree_sitter_debug: Debug = .init; -var image_debug: Debug = .init; -var pdf_debug: Debug = .init; + fn get(self: *@This()) Allocator { + self.fixed = .init(self.buffer); + return .{ .ptr = self, .vtable = &.{ .alloc = alloc, .resize = resize, .remap = remap, .free = free } }; + } -// One session at a time; free its allocations before deinit. Concurrent LSP workers use the caller's allocator. -pub fn init(fallback: Allocator) Allocators { - pardes_fallback.fallback_allocator = fallback; - pardes_fallback.get_called = if (std.debug.runtime_safety) false else {}; - frame_fallback.fallback_allocator = fallback; - frame_fallback.get_called = if (std.debug.runtime_safety) false else {}; - tree_sitter_fallback.fallback_allocator = fallback; - tree_sitter_fallback.get_called = if (std.debug.runtime_safety) false else {}; - image_fallback.fallback_allocator = fallback; - image_fallback.get_called = if (std.debug.runtime_safety) false else {}; - pdf_fallback.fallback_allocator = fallback; - pdf_fallback.get_called = if (std.debug.runtime_safety) false else {}; + fn alloc(ctx: *anyopaque, len: usize, alignment: std.mem.Alignment, ra: usize) ?[*]u8 { + const self: *@This() = @ptrCast(@alignCast(ctx)); + return self.fixed.threadSafeAllocator().rawAlloc(len, alignment, ra) orelse + self.fallback_allocator.rawAlloc(len, alignment, ra); + } + + fn resize(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ra: usize) bool { + const self: *@This() = @ptrCast(@alignCast(ctx)); + if (self.fixed.ownsPtr(buf.ptr)) return self.fixed.threadSafeAllocator().rawResize(buf, alignment, new_len, ra); + return self.fallback_allocator.rawResize(buf, alignment, new_len, ra); + } + + fn remap(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ra: usize) ?[*]u8 { + const self: *@This() = @ptrCast(@alignCast(ctx)); + if (self.fixed.ownsPtr(buf.ptr)) return self.fixed.threadSafeAllocator().rawRemap(buf, alignment, new_len, ra); + return self.fallback_allocator.rawRemap(buf, alignment, new_len, ra); + } + + fn free(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, ra: usize) void { + const self: *@This() = @ptrCast(@alignCast(ctx)); + if (self.fixed.ownsPtr(buf.ptr)) return self.fixed.threadSafeAllocator().rawFree(buf, alignment, ra); + return self.fallback_allocator.rawFree(buf, alignment, ra); + } +}; + +/// One arena's fixed region on a native target, handed out in runs of 4 KiB +/// granules to the general allocator above it (`Region.general`). A freed run +/// is used again, and big ones go back to the system (`release`; `trim` +/// gives back the rest), so what is resident follows what is in use. When no +/// run fits, the block spills to the heap (`spill`) and is counted in +/// `spilled`. Called only under the general allocator's mutex. +const Pages = struct { + region: []u8 = @constCast(&[_]u8{}), + used: []u64 = &.{}, + spill: Allocator = undefined, + spilled: usize = 0, + /// Past the highest granule used yet: where `trim` stops. + top: usize = 0, + + const granule = 4 * KiB; + /// A freed run from `release_min` up to `keep_min` goes back at once: + /// kept until `trim`, a V8 Callstack page's emptied buckets and middling + /// blocks took its peak from 160 to 219 MiB. A bigger one stays resident + /// until `trim`: the next block of its size takes it without faulting it + /// in again, which each keystroke in a 7 MB file does (its edit's copy of + /// the text frees the one before; given back at once, 2.0 -> 3.2 ms a key). + const release_min = 64 * KiB; + const keep_min = 1 * MiB; + + fn allocator(self: *Pages) Allocator { + return .{ .ptr = self, .vtable = &.{ .alloc = alloc, .resize = resize, .remap = remap, .free = free } }; + } + + fn owns(self: *const Pages, ptr: [*]u8) bool { + const at = @intFromPtr(ptr) -% @intFromPtr(self.region.ptr); + return at < self.region.len; + } + + fn alloc(ctx: *anyopaque, len: usize, alignment: std.mem.Alignment, ra: usize) ?[*]u8 { + const self: *Pages = @ptrCast(@alignCast(ctx)); + const n = std.math.divCeil(usize, len, granule) catch unreachable; + const step = @max(1, alignment.toByteUnits() / granule); + if (find(self.used, n, step)) |start| { + mark(self.used, start, n, true); + self.top = @max(self.top, start + n); + return self.region.ptr + start * granule; + } + const ptr = self.spill.rawAlloc(len, alignment, ra) orelse return null; + self.spilled += len; + return ptr; + } + + fn resize(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ra: usize) bool { + const self: *Pages = @ptrCast(@alignCast(ctx)); + if (!self.owns(buf.ptr)) { + if (!self.spill.rawResize(buf, alignment, new_len, ra)) return false; + self.spilled = self.spilled - buf.len + new_len; + return true; + } + const start = (@intFromPtr(buf.ptr) - @intFromPtr(self.region.ptr)) / granule; + const n = std.math.divCeil(usize, buf.len, granule) catch unreachable; + const want = std.math.divCeil(usize, new_len, granule) catch unreachable; + if (want <= n) { + self.release(start + want, n - want); + return true; + } + if (start + want > self.used.len * 64 or freeRun(self.used, start + n, want - n) < want - n) return false; + mark(self.used, start + n, want - n, true); + self.top = @max(self.top, start + want); + return true; + } + + fn remap(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ra: usize) ?[*]u8 { + const self: *Pages = @ptrCast(@alignCast(ctx)); + if (!self.owns(buf.ptr)) { + const ptr = self.spill.rawRemap(buf, alignment, new_len, ra) orelse return null; + self.spilled = self.spilled - buf.len + new_len; + return ptr; + } + return if (resize(ctx, buf, alignment, new_len, ra)) buf.ptr else null; + } + + fn free(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, ra: usize) void { + const self: *Pages = @ptrCast(@alignCast(ctx)); + if (!self.owns(buf.ptr)) { + self.spilled -= buf.len; + return self.spill.rawFree(buf, alignment, ra); + } + const start = (@intFromPtr(buf.ptr) - @intFromPtr(self.region.ptr)) / granule; + self.release(start, std.math.divCeil(usize, buf.len, granule) catch unreachable); + } + + fn release(self: *Pages, start: usize, n: usize) void { + mark(self.used, start, n, false); + if (n * granule >= release_min and n * granule < keep_min) advise(self.region[start * granule ..][0 .. n * granule], std.posix.MADV.DONTNEED); + } + + /// Gives back the pages of every free run in `n` granules from `start`. + fn giveBack(self: *Pages, start: usize, n: usize) void { + var i = start; + while (i < start + n) { + if (i % 64 == 0 and self.used[i / 64] == ~@as(u64, 0)) { + i += 64; + continue; + } + const run = freeRun(self.used, i, start + n - i); + if (run > 0) advise(self.region[i * granule ..][0 .. run * granule], std.posix.MADV.DONTNEED); + i += run + 1; + } + } + + /// Gives back every free run below `top`: the small ones `release` + /// keeps resident, small and big. + fn trim(self: *Pages) void { + self.giveBack(0, self.top); + } + + /// The first free run of `n` granules starting at a multiple of `step`. + // ponytail: first fit, a scan of the region's bitmap (32 KiB for 1 GiB) + // per page-sized block; a free-run index if a profile ever shows it. + fn find(used: []const u64, n: usize, step: usize) ?usize { + const total = used.len * 64; + var start: usize = 0; + while (start + n <= total) { + if (start % 64 == 0 and used[start / 64] == ~@as(u64, 0)) { + start = std.mem.alignForward(usize, start + 64, step); + continue; + } + const got = freeRun(used, start, n); + if (got == n) return start; + start = std.mem.alignForward(usize, start + got + 1, step); + } + return null; + } + + /// How many of the `n` granules from `start` are free before a used one. + fn freeRun(used: []const u64, start: usize, n: usize) usize { + var i = start; + while (i < start + n) { + if (i % 64 == 0 and start + n - i >= 64 and used[i / 64] == 0) { + i += 64; + continue; + } + if (used[i / 64] >> @intCast(i % 64) & 1 != 0) break; + i += 1; + } + return i - start; + } + + fn mark(used: []u64, start: usize, n: usize, set: bool) void { + var i = start; + while (i < start + n) { + if (i % 64 == 0 and start + n - i >= 64) { + used[i / 64] = if (set) ~@as(u64, 0) else 0; + i += 64; + continue; + } + const bit = @as(u64, 1) << @intCast(i % 64); + if (set) used[i / 64] |= bit else used[i / 64] &= ~bit; + i += 1; + } + } +}; + +/// The general allocator over one arena's region: std's DebugAllocator for +/// its size classes, its checks and leak report only in a Debug build. +const General = std.heap.DebugAllocator(.{ + .safety = debug_enabled, + .thread_safe = true, + .backing_allocator_zeroes = false, + .page_size = 64 * KiB, +}); + +/// One arena: its region, the bitmap of its used granules, and the +/// allocator over them. A native region is address space mapped once, at the +/// first `init`, not .bss: gigabytes of .bss put static data out of reach of +/// x86-64's 32-bit offsets. A freestanding one is its .bss `buffer`. +const Region = struct { + size: usize, + bits: []u64, + buffer: []u8, + pages: Pages = .{}, + general: General = .init, + fallback: SharedStackFallback = undefined, + + fn init(r: *Region, spill: Allocator) Allocator { + if (reduced_target) { + r.fallback = .{ .buffer = r.buffer, .fallback_allocator = spill }; + return r.fallback.get(); + } + // Without the mapping (an address-space limit) every block spills. + const region = if (r.pages.region.len > 0) r.pages.region else if (std.heap.page_allocator.rawAlloc(r.size, .fromByteUnits(64 * KiB), @returnAddress())) |ptr| ptr[0..r.size] else @constCast(&[_]u8{}); + sparse(region); + @memset(r.bits, 0); + r.pages = .{ .region = region, .used = r.bits[0 .. region.len / Pages.granule / 64], .spill = spill }; + r.general = .{ .backing_allocator = r.pages.allocator() }; + return r.general.allocator(); + } + + fn trim(r: *Region) void { + if (reduced_target) return; + std.Io.Threaded.mutexLockUncancelable(&r.general.mutex); + defer std.Io.Threaded.mutexUnlock(&r.general.mutex); + r.pages.trim(); + } + + /// A fresh allocator in its place: a Debug deinit leaves 0xAA behind, + /// its mutex too, which a later `trim` would wait on for good. + fn deinit(r: *Region) bool { + if (reduced_target) return false; + const leaked = r.general.deinit() == .leak; + r.general = .{ .backing_allocator = r.pages.allocator() }; + return leaked; + } +}; - const raw: Allocators = .{ - .pardes = pardes_fallback.get(), - .frame = frame_fallback.get(), - .lsp = fallback, - .tree_sitter = tree_sitter_fallback.get(), - .image = image_fallback.get(), - .pdf = pdf_fallback.get(), +/// Each arena's bitmap on a native target, its buffer on a freestanding one; +/// spelled out per arena: a generic returning the globals would share them +/// between two arenas of one size. +fn bitsFor(size: usize) usize { + return if (reduced_target) 0 else size / Pages.granule / 64; +} +fn bufferFor(size: usize) usize { + return if (reduced_target) size else 0; +} +var pardes_bits: [bitsFor(limits.arena.pardes)]u64 = @splat(0); +var pardes_buffer: [bufferFor(limits.arena.pardes)]u8 = @splat(0); +var pardes_region: Region = .{ .size = limits.arena.pardes, .bits = &pardes_bits, .buffer = &pardes_buffer }; +var frame_bits: [bitsFor(limits.arena.frame)]u64 = @splat(0); +var frame_buffer: [bufferFor(limits.arena.frame)]u8 = @splat(0); +var frame_region: Region = .{ .size = limits.arena.frame, .bits = &frame_bits, .buffer = &frame_buffer }; +var lsp_bits: [bitsFor(limits.arena.lsp)]u64 = @splat(0); +var lsp_buffer: [bufferFor(limits.arena.lsp)]u8 = @splat(0); +var lsp_region: Region = .{ .size = limits.arena.lsp, .bits = &lsp_bits, .buffer = &lsp_buffer }; +var tree_sitter_bits: [bitsFor(limits.arena.tree_sitter)]u64 = @splat(0); +var tree_sitter_buffer: [bufferFor(limits.arena.tree_sitter)]u8 = @splat(0); +var tree_sitter_region: Region = .{ .size = limits.arena.tree_sitter, .bits = &tree_sitter_bits, .buffer = &tree_sitter_buffer }; +var image_bits: [bitsFor(limits.arena.image)]u64 = @splat(0); +var image_buffer: [bufferFor(limits.arena.image)]u8 = @splat(0); +var image_region: Region = .{ .size = limits.arena.image, .bits = &image_bits, .buffer = &image_buffer }; +var pdf_bits: [bitsFor(limits.arena.pdf)]u64 = @splat(0); +var pdf_buffer: [bufferFor(limits.arena.pdf)]u8 = @splat(0); +var pdf_region: Region = .{ .size = limits.arena.pdf, .bits = &pdf_bits, .buffer = &pdf_buffer }; +var host_bits: [bitsFor(limits.arena.host)]u64 = @splat(0); +var host_buffer: [bufferFor(limits.arena.host)]u8 = @splat(0); +var host_region: Region = .{ .size = limits.arena.host, .bits = &host_bits, .buffer = &host_buffer }; + +/// The allocator a native shell allocates itself from, over its own arena, +/// for the life of the process (no `deinit`); what does not fit spills to +/// `spill`. A release build's: a Debug build keeps std.start's allocator +/// for its leak report. +pub fn host(spill: Allocator) Allocator { + return host_region.init(spill); +} + +var lsp_query_buffer: [limits.arena.lsp_query]u8 align(std.heap.page_size_max) = @splat(0); +var lsp_query_busy: std.atomic.Value(bool) = .init(false); +/// What a query may leave resident of the region (giveLspQuery). +const lsp_query_kept = 8 * MiB; + +/// The language query region, for the one query running; null while another +/// holds it (the shells cancel and join a query before starting the next). +pub fn takeLspQuery() ?[]u8 { + if (lsp_query_busy.swap(true, .acquire)) return null; + return &lsp_query_buffer; +} + +/// Gives the region back after a query. A big one's touched pages go back to +/// the system (zeroed again on their next touch, as .bss is), so one huge +/// answer does not stay resident; a small one's stay, for the next query to +/// reuse without faulting them in again. +pub fn giveLspQuery(used: usize) void { + if (comptime builtin.os.tag == .linux) if (used > lsp_query_kept) { + const page = std.heap.pageSize(); + const len = std.mem.alignForward(usize, @min(used, lsp_query_buffer.len), page); + std.posix.madvise(@as([*]align(std.heap.page_size_min) u8, @ptrCast(&lsp_query_buffer)), len, std.posix.MADV.DONTNEED) catch {}; + }; + lsp_query_busy.store(false, .release); +} + +/// `n` bytes as they come: `Allocator.alloc` fills a safe build's new memory +/// as `undefined` (0xAA), which writes, and makes resident, all of a buffer +/// sized for the worst case: every language query wrote its 51 MB answer +/// room, every search its 16 MiB. For buffers written before they are read. +pub fn unfilled(allocator: Allocator, n: usize) Allocator.Error![]u8 { + if (n == 0) return allocator.alloc(u8, 0); + const ptr = allocator.rawAlloc(n, .of(u8), @returnAddress()) orelse return error.OutOfMemory; + return ptr[0..n]; +} + +/// `bytes` copied into memory `unfilled` takes: a text-sized copy (an undo +/// snapshot) is written once, not filled first. +pub fn dupeUnfilled(allocator: Allocator, bytes: []const u8) Allocator.Error![]u8 { + const out = try unfilled(allocator, bytes.len); + @memcpy(out, bytes); + return out; +} + +/// Frees without the safe-build overwrite `free` does, for text-sized buffers +/// freed on every edit. +pub fn freeUnfilled(allocator: Allocator, bytes: []const u8) void { + if (bytes.len > 0) allocator.rawFree(@constCast(bytes), .of(u8), @returnAddress()); +} + +/// Gives free memory back to the system, the arenas' and libc's, inside its +/// heap too: after a big result is formatted or a big pane torn down, the +/// tree-sitter arena kept 73 MiB of emptied buckets resident and glibc what +/// was freed (a V8 Callstack page left 21 MiB free in its heap; this returned +/// 20). Walks every arena and the heap, so for rare, large events only. +pub fn trim() void { + inline for (.{ &pardes_region, &frame_region, &lsp_region, &tree_sitter_region, &image_region, &pdf_region, &host_region }) |r| r.trim(); + if (comptime builtin.os.tag != .linux or builtin.abi.isMusl() or !builtin.link_libc) return; + const glibc = struct { + extern "c" fn malloc_trim(pad: usize) c_int; }; - if (!debug_enabled) return raw; + _ = glibc.malloc_trim(0); +} + +/// Marks a big region that is touched sparsely as not for huge pages. With +/// transparent huge pages on `always` (a common default), touching one byte +/// of a 2 MiB-aligned stretch makes all 2 MiB resident: the 9P runner's +/// slots and these arenas' first pages held 45 MiB of an idle session's +/// 71 MiB that way. Only the region given, never the whole process (a prctl +/// would reach every shell and server pardes starts). +pub fn sparse(region: []u8) void { + advise(region, std.posix.MADV.NOHUGEPAGE); +} - pardes_debug = .{ .backing_allocator = raw.pardes }; - frame_debug = .{ .backing_allocator = raw.frame }; - lsp_debug = .{ .backing_allocator = raw.lsp }; - tree_sitter_debug = .{ .backing_allocator = raw.tree_sitter }; - image_debug = .{ .backing_allocator = raw.image }; - pdf_debug = .{ .backing_allocator = raw.pdf }; +/// madvise over the whole pages inside `region`. +fn advise(region: []u8, advice: u32) void { + if (comptime builtin.os.tag != .linux) return; + const page = std.heap.pageSize(); + const start = std.mem.alignForward(usize, @intFromPtr(region.ptr), page); + const end = std.mem.alignBackward(usize, @intFromPtr(region.ptr) + region.len, page); + if (end <= start) return; + std.posix.madvise(@ptrFromInt(start), end - start, advice) catch {}; +} + +// One session at a time; free its allocations before deinit. The language +// workers allocate their answers from `lsp` on their own threads. +pub fn init(fallback: Allocator) Allocators { + // Beneath a Debug build's arenas goes the page allocator rather than + // `fallback`: in a Debug build `fallback` is std.process.Init's gpa, a + // DebugAllocator already, and the arenas' own check every block. + const spill = if (debug_enabled) std.heap.page_allocator else fallback; + sparse(&lsp_query_buffer); return .{ - .pardes = pardes_debug.allocator(), - .frame = frame_debug.allocator(), - .lsp = lsp_debug.allocator(), - .tree_sitter = tree_sitter_debug.allocator(), - .image = image_debug.allocator(), - .pdf = pdf_debug.allocator(), + .pardes = pardes_region.init(spill), + .frame = frame_region.init(spill), + .lsp = lsp_region.init(spill), + .tree_sitter = tree_sitter_region.init(spill), + .image = image_region.init(spill), + .pdf = pdf_region.init(spill), }; } +/// A Debug build's leak report, each arena's own (it panics on a leak). pub fn deinit() void { if (!debug_enabled) return; - var leaked = pardes_debug.deinit() == .leak; - leaked = (frame_debug.deinit() == .leak) or leaked; - leaked = (lsp_debug.deinit() == .leak) or leaked; - leaked = (tree_sitter_debug.deinit() == .leak) or leaked; - leaked = (image_debug.deinit() == .leak) or leaked; - leaked = (pdf_debug.deinit() == .leak) or leaked; + var leaked = pardes_region.deinit(); + leaked = frame_region.deinit() or leaked; + leaked = lsp_region.deinit() or leaked; + leaked = tree_sitter_region.deinit() or leaked; + leaked = image_region.deinit() or leaked; + leaked = pdf_region.deinit() or leaked; if (leaked) @panic("allocator leaks detected"); } -test "fixed allocators are separate, spill, and restart" { +test "arenas are separate, reuse what is freed, spill, and restart" { + if (reduced_target) return error.SkipZigTest; var allocs = init(std.testing.allocator); const core = try allocs.pardes.alloc(u8, 32); const frame = try allocs.frame.alloc(u8, 32); - try std.testing.expect(pardes_fallback.fixed_buffer_allocator.ownsPtr(core.ptr)); - try std.testing.expect(frame_fallback.fixed_buffer_allocator.ownsPtr(frame.ptr)); - try std.testing.expect(core.ptr != frame.ptr); + try std.testing.expect(pardes_region.pages.owns(core.ptr)); + try std.testing.expect(frame_region.pages.owns(frame.ptr)); - const spill = try allocs.pardes.alloc(u8, limits.arena.pardes + 1); - try std.testing.expect(!pardes_fallback.fixed_buffer_allocator.ownsPtr(spill.ptr)); - allocs.pardes.free(spill); + // A freed block is used again: a FixedBufferAllocator's was not, unless + // it was the last one, so an arena filled once and spilled after. + const big = try unfilled(allocs.pardes, 8 * MiB); + const after = try allocs.pardes.alloc(u8, 32); + freeUnfilled(allocs.pardes, big); + const again = try unfilled(allocs.pardes, 8 * MiB); + try std.testing.expectEqual(big.ptr, again.ptr); + + const spill = try unfilled(allocs.pardes, limits.arena.pardes + 1); + try std.testing.expect(!pardes_region.pages.owns(spill.ptr)); + try std.testing.expectEqual(limits.arena.pardes + 1, pardes_region.pages.spilled); + freeUnfilled(allocs.pardes, spill); + try std.testing.expectEqual(0, pardes_region.pages.spilled); + freeUnfilled(allocs.pardes, again); + allocs.pardes.free(after); allocs.frame.free(frame); allocs.pardes.free(core); deinit(); @@ -127,7 +516,21 @@ test "fixed allocators are separate, spill, and restart" { defer deinit(); const restarted = try allocs.pardes.alloc(u8, 32); defer allocs.pardes.free(restarted); - try std.testing.expect(pardes_fallback.fixed_buffer_allocator.ownsPtr(restarted.ptr)); + try std.testing.expect(pardes_region.pages.owns(restarted.ptr)); +} + +test "a region's runs: aligned first fit, growth in place, release" { + var used: [2]u64 = @splat(0); + Pages.mark(&used, 0, 3, true); + try std.testing.expectEqual(@as(?usize, 4), Pages.find(&used, 2, 4)); + try std.testing.expectEqual(@as(?usize, 3), Pages.find(&used, 70, 1)); + try std.testing.expectEqual(@as(?usize, null), Pages.find(&used, 126, 1)); + try std.testing.expectEqual(@as(?usize, 3), Pages.find(&used, 125, 1)); + Pages.mark(&used, 3, 125, true); + try std.testing.expectEqual(~@as(u64, 0), used[1]); + Pages.mark(&used, 10, 100, false); + try std.testing.expectEqual(@as(usize, 100), Pages.freeRun(&used, 10, 100)); + try std.testing.expectEqual(@as(usize, 100), Pages.freeRun(&used, 10, 101)); } test "memory limits preserve desktop capacities" { @@ -137,13 +540,15 @@ test "memory limits preserve desktop capacities" { try std.testing.expectEqual(256, limits.wrap_rows); try std.testing.expectEqual(256, limits.undo_max); try std.testing.expectEqual(128, limits.message_log); + try std.testing.expectEqual(1024, limits.selections); try std.testing.expectEqual(@as(usize, 4096), limits.max_tag_tail); try std.testing.expectEqual(@as(usize, 4095), limits.host_path_cap); try std.testing.expectEqual(config.embed_sources, limits.embedded_sources); try std.testing.expectEqual(@as(u32, 16), limits.hexdump_row_bytes); - try std.testing.expectEqual(32 * MiB, limits.arena.pardes); - try std.testing.expectEqual(16 * MiB, limits.arena.frame); - try std.testing.expectEqual(16 * MiB, limits.arena.tree_sitter); - try std.testing.expectEqual(32 * MiB, limits.arena.image); - try std.testing.expectEqual(if (config.mupdf) 64 * MiB else 64 * KiB, limits.arena.pdf); + try std.testing.expectEqual(1024 * MiB, limits.arena.pardes); + try std.testing.expectEqual(64 * MiB, limits.arena.frame); + try std.testing.expectEqual(512 * MiB, limits.arena.lsp); + try std.testing.expectEqual(256 * MiB, limits.arena.tree_sitter); + try std.testing.expectEqual(256 * MiB, limits.arena.image); + try std.testing.expectEqual(if (config.mupdf) 512 * MiB else 64 * KiB, limits.arena.pdf); } |
