Is it Ok to use std.heap.page_allocator directly?

squeek502 · December 26, 2023, 7:46am

My answer is essentially “no”:

Not directly related, but here’s some info regarding page_allocator being used as the backing allocator for an ArenaAllocator:

github.com/ziglang/zig

Pattern: `Lot` data structure for scope-lifetime nonresizable arrays of runtime-known length

opened 03:46PM - 21 Oct 23 UTC

closed 12:43AM - 29 Mar 24 UTC

expikr

standard library proposal

I've been using this pattern a fair bit when interfacing with C APIs that requir…e a temporary buffer of runtime-known length. Since it's only a temporary buffer, it does not need to be resized, and *should be dropped immediately upon exiting the current scope.* For this purpose, stack allocation fits all of the requirements _except_ for its length being runtime-known. I just want a runtime-sized stack allocation that don't overflow, the full dance of ArrayList+Allocator is a bit overkill when the data assuredly never outlives the current scope. So the idea is to just have one _permanent arena_ ("permarena") per each datatype that ever instantiates fixed-lifetime fixed-length dynamic arrays. (i.e. having `Lot(MyType)` anywhere will instantiate, at compile time, a single homogeneous arena shared by all instances of MyType Lots, which lives for the duration of the program) Due to the scope-lifetime constraint, the `defer` train always frees in order and the arena stays contiguous. This approach is an ergonomic middleground with only a single extra `defer buffer.free()` compared to dynamic languages. *Foregoing the ability to outlive the current scope* allows it to have a very simple interface not worrying about which allocator to use, since the allocation strategy is constrained. ```zig pub fn Lot(comptime T: type) type { return struct { items: []T, var permarena = std.heap.ArenaAllocator.init(std.heap.page_allocator); const allocator = permarena.allocator(); const Self = @This(); pub fn free(self: Self) void { allocator.free(self.items); } pub fn new(count: usize) ?Self { const items = allocator.alloc(T,count) catch { return null; }; return .{ .items = items, }; } }; } ``` Example Usage: ```zig const std = @include("std"); const net = @include("net.zig"); const Lot = @include("Lot.zig").Lot; const Person = struct { height: u32, weight: u32, const Self = @This(); const Selves = Lot(Self); // this instantiates the arena for type Lot(Person) pub fn newLot(count: usize) ?Selves { return Selves.new(count); } }; pub fn main() void { const src = net.listen("localhost"); const num = src.numPeopleInQueue(); // runtime-known length, unknown upper-bound if (Person.newLot(num)) |lot| { // could also just use Lot(Person).new(num) directly defer lot.free(); var items = lot.items; _ = src.getPeopleInQueue(items.ptr, items.len); // c api that takes a ptr and a len for (items) |item| { std.debug.print("{?}",.{item}); } } } ```