summaryrefslogtreecommitdiff
path: root/src/memory.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/memory.zig')
-rw-r--r--src/memory.zig98
1 files changed, 98 insertions, 0 deletions
diff --git a/src/memory.zig b/src/memory.zig
index 48403c55..853d641a 100644
--- a/src/memory.zig
+++ b/src/memory.zig
@@ -16,6 +16,10 @@ 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
@@ -23,6 +27,19 @@ pub const limits = struct {
/// /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;
@@ -34,6 +51,10 @@ pub const limits = struct {
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;
};
};
@@ -96,6 +117,82 @@ 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 };
@@ -118,6 +215,7 @@ pub fn init(fallback: Allocator) Allocators {
// 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;