const std = @import("std"); const builtin = @import("builtin"); const config = @import("pardes_config"); const board = config.platform == .esp32p4; const reduced_target = builtin.os.tag == .freestanding; const KiB = 1024; const MiB = 1024 * KiB; pub const limits = struct { pub const max_file_bytes = 256 * MiB; pub const max_stream_bytes = 4 * MiB; // P4: 384 KiB heap; static buffers and stack share a separate 240 KiB region. pub const board_heap_bytes = 384 * KiB; pub const effect_cap = if (board) 128 else 4096; 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; 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; /// 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; pub const Allocators = struct { pardes: Allocator, frame: Allocator, lsp: Allocator, tree_sitter: Allocator, image: Allocator, pdf: Allocator, }; /// `std.heap.StackFallbackAllocator` with the buffer taken through its /// lock-free interface. 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, fn get(self: *@This()) Allocator { self.fixed = .init(self.buffer); return .{ .ptr = self, .vtable = &.{ .alloc = alloc, .resize = resize, .remap = remap, .free = free } }; } 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); } }; var pardes_buffer: [limits.arena.pardes]u8 = @splat(0); var frame_buffer: [limits.arena.frame]u8 = @splat(0); var tree_sitter_buffer: [limits.arena.tree_sitter]u8 = @splat(0); var image_buffer: [limits.arena.image]u8 = @splat(0); var pdf_buffer: [limits.arena.pdf]u8 = @splat(0); 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 libc's free memory back to the system, inside its heap too: after a /// big result is formatted or a big pane torn down, glibc keeps what was freed /// (a V8 Callstack page left 21 MiB free in the heap; this returned 20). /// Walks the heap, so for rare, large events only. pub fn trim() void { 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; }; _ = 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 { 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, std.posix.MADV.NOHUGEPAGE) catch {}; } var pardes_fallback: SharedStackFallback = .{ .buffer = &pardes_buffer }; var frame_fallback: SharedStackFallback = .{ .buffer = &frame_buffer }; var tree_sitter_fallback: SharedStackFallback = .{ .buffer = &tree_sitter_buffer }; var image_fallback: SharedStackFallback = .{ .buffer = &image_buffer }; var pdf_fallback: SharedStackFallback = .{ .buffer = &pdf_buffer }; 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; // One session at a time; free its allocations before deinit. Concurrent LSP workers use the caller's allocator. pub fn init(fallback: Allocator) Allocators { // A Debug build puts each allocator under a DebugAllocator of its own, // which reports that subsystem's leaks and bad frees (deinit panics on a // leak). Beneath that goes the page allocator rather than `fallback`: in // a Debug build `fallback` is std.process.Init's gpa, a DebugAllocator // already, and a second one checked every block twice. const backing = if (debug_enabled) std.heap.page_allocator else fallback; inline for (.{ &pardes_buffer, &frame_buffer, &tree_sitter_buffer, &image_buffer, &pdf_buffer, &lsp_query_buffer }) |buffer| sparse(buffer); pardes_fallback.fallback_allocator = backing; frame_fallback.fallback_allocator = backing; tree_sitter_fallback.fallback_allocator = backing; image_fallback.fallback_allocator = backing; pdf_fallback.fallback_allocator = backing; const raw: Allocators = .{ .pardes = pardes_fallback.get(), .frame = frame_fallback.get(), .lsp = backing, .tree_sitter = tree_sitter_fallback.get(), .image = image_fallback.get(), .pdf = pdf_fallback.get(), }; if (!debug_enabled) return raw; 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 }; 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(), }; } 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; if (leaked) @panic("allocator leaks detected"); } test "fixed allocators are separate, spill, and restart" { 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.ownsPtr(core.ptr)); try std.testing.expect(frame_fallback.fixed.ownsPtr(frame.ptr)); try std.testing.expect(core.ptr != frame.ptr); const spill = try allocs.pardes.alloc(u8, limits.arena.pardes + 1); try std.testing.expect(!pardes_fallback.fixed.ownsPtr(spill.ptr)); allocs.pardes.free(spill); allocs.frame.free(frame); allocs.pardes.free(core); deinit(); allocs = init(std.testing.allocator); defer deinit(); const restarted = try allocs.pardes.alloc(u8, 32); defer allocs.pardes.free(restarted); try std.testing.expect(pardes_fallback.fixed.ownsPtr(restarted.ptr)); } test "memory limits preserve desktop capacities" { if (board or reduced_target) return error.SkipZigTest; try std.testing.expectEqual(4096, limits.effect_cap); try std.testing.expectEqual(@as(usize, 4 * MiB), limits.pending_write_cap); 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); }