summaryrefslogtreecommitdiff
path: root/src/memory.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/memory.zig')
-rw-r--r--src/memory.zig543
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);
}