1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
|
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;
/// 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 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;
pub const Allocators = struct {
pardes: Allocator,
frame: Allocator,
lsp: Allocator,
tree_sitter: Allocator,
image: Allocator,
pdf: Allocator,
};
/// 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,
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);
}
};
/// 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;
}
};
/// 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;
};
_ = 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);
}
/// 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_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_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 "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_region.pages.owns(core.ptr));
try std.testing.expect(frame_region.pages.owns(frame.ptr));
// 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();
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_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" {
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(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);
}
|