mirror of
https://github.com/lightpanda-io/browser.git
synced 2026-03-22 04:34:44 +00:00
e23ef4b0be
This removes the browser-specific arenas (session, transfer, page, call) in favor of the arena pool. This is a bit of a win-lose commit. It exists as (the last?) step before I can really start working on frames. Frames will require their own "page" and "call" arenas, so there isn't just 1 per browser now, but rather N, where N is the number of frames + 1 page. This change was already done for Contexts when ExecutionWorld was removed, and the idea is the same: making these units more self contained so to support cases where we break out of the "1" model we currently have (1 browser, 1 session, 1 page, 1 context, ...). But it's a bit of a step backwards because the ArenaPool is dumb and just resets everything to a single hard-coded (for now) value: 16KB. But in my mind, an arena that's used for 1 thing (e.g. the page or call arenas) is more likely to be well-sized for that specific role in the future, even on a different page/navigate. I think ultimately, we'll move to an ArenaPool that has different levels, e.g. acquire() and acquireLarge() which can reset to different sizes, so that a page arena can use acquireLarge() and retain a larger amount of memory between use.
93 lines
2.7 KiB
Zig
93 lines
2.7 KiB
Zig
// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)
|
|
//
|
|
// Francis Bouvier <francis@lightpanda.io>
|
|
// Pierre Tachoire <pierre@lightpanda.io>
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
const std = @import("std");
|
|
|
|
const Allocator = std.mem.Allocator;
|
|
const ArenaAllocator = std.heap.ArenaAllocator;
|
|
|
|
const ArenaPool = @This();
|
|
|
|
allocator: Allocator,
|
|
retain_bytes: usize,
|
|
free_list_len: u16 = 0,
|
|
free_list: ?*Entry = null,
|
|
free_list_max: u16,
|
|
entry_pool: std.heap.MemoryPool(Entry),
|
|
|
|
const Entry = struct {
|
|
next: ?*Entry,
|
|
arena: ArenaAllocator,
|
|
};
|
|
|
|
pub fn init(allocator: Allocator) ArenaPool {
|
|
return .{
|
|
.allocator = allocator,
|
|
.free_list_max = 512, // TODO make configurable
|
|
.retain_bytes = 1024 * 16, // TODO make configurable
|
|
.entry_pool = std.heap.MemoryPool(Entry).init(allocator),
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *ArenaPool) void {
|
|
var entry = self.free_list;
|
|
while (entry) |e| {
|
|
entry = e.next;
|
|
e.arena.deinit();
|
|
}
|
|
self.entry_pool.deinit();
|
|
}
|
|
|
|
pub fn acquire(self: *ArenaPool) !Allocator {
|
|
if (self.free_list) |entry| {
|
|
self.free_list = entry.next;
|
|
self.free_list_len -= 1;
|
|
return entry.arena.allocator();
|
|
}
|
|
|
|
const entry = try self.entry_pool.create();
|
|
entry.* = .{
|
|
.next = null,
|
|
.arena = ArenaAllocator.init(self.allocator),
|
|
};
|
|
|
|
return entry.arena.allocator();
|
|
}
|
|
|
|
pub fn release(self: *ArenaPool, allocator: Allocator) void {
|
|
const arena: *std.heap.ArenaAllocator = @ptrCast(@alignCast(allocator.ptr));
|
|
const entry: *Entry = @fieldParentPtr("arena", arena);
|
|
|
|
const free_list_len = self.free_list_len;
|
|
if (free_list_len == self.free_list_max) {
|
|
arena.deinit();
|
|
self.entry_pool.destroy(entry);
|
|
return;
|
|
}
|
|
|
|
_ = arena.reset(.{ .retain_with_limit = self.retain_bytes });
|
|
entry.next = self.free_list;
|
|
self.free_list_len = free_list_len + 1;
|
|
self.free_list = entry;
|
|
}
|
|
|
|
pub fn reset(_: *const ArenaPool, allocator: Allocator, retain: usize) void {
|
|
const arena: *std.heap.ArenaAllocator = @ptrCast(@alignCast(allocator.ptr));
|
|
_ = arena.reset(.{ .retain_with_limit = retain });
|
|
}
|