Skip to content

Lightpanda: the headless browser designed for AI and automation

chore: Replace deprecated MemoryPool with Managed Memory Pool

Karl Seguin6716f1c12a20
diff --git a/src/ArenaPool.zig b/src/ArenaPool.zig
index 10d7596ca..95327a4f2 100644
--- a/src/ArenaPool.zig
+++ b/src/ArenaPool.zig
@@ -65,14 +65,14 @@ medium: Bucket,
large: Bucket,
allocator: Allocator,
mutex: std.Io.Mutex = .init,
-entry_pool: std.heap.memory_pool.ExtraManaged(Entry, .{}),
+entry_pool: std.heap.MemoryPool(Entry),
_leak_track: if (IS_DEBUG) std.StringHashMapUnmanaged(isize) else void = if (IS_DEBUG) .empty else {},
pub fn init(allocator: Allocator, config: Config) ArenaPool {
return .{
.allocator = allocator,
- .entry_pool = .init(allocator),
+ .entry_pool = .empty,
.tiny = .{ .free_list_max = config.tiny.max, .retain_bytes = config.tiny.retain },
.small = .{ .free_list_max = config.small.max, .retain_bytes = config.small.retain },
.medium = .{ .free_list_max = config.medium.max, .retain_bytes = config.medium.retain },
@@ -104,7 +104,7 @@ pub fn deinit(self: *ArenaPool) void {
e.arena.deinit();
}
}
- self.entry_pool.deinit();
+ self.entry_pool.deinit(self.allocator);
}
// Acquire an arena from the pool.
@@ -152,7 +152,7 @@ pub fn acquire(self: *ArenaPool, size_or_bucket: anytype, debug: []const u8) !Al
lp.metrics.arena_miss.incr(bucket_size);
- const entry = try self.entry_pool.create();
+ const entry = try self.entry_pool.create(self.allocator);
entry.* = .{
.next = null,
.bucket = bucket,
diff --git a/src/Notification.zig b/src/Notification.zig
index 74fd5af3f..9fcfb7fbf 100644
--- a/src/Notification.zig
+++ b/src/Notification.zig
@@ -68,7 +68,7 @@ event_listeners: EventListeners,
listeners: std.AutoHashMapUnmanaged(usize, std.ArrayList(*Listener)),
allocator: Allocator,
-mem_pool: std.heap.memory_pool.ExtraManaged(Listener, .{}),
+mem_pool: std.heap.MemoryPool(Listener),
const EventListeners = struct {
frame_remove: List = .{},
@@ -371,9 +371,9 @@ pub fn init(allocator: Allocator) !*Notification {
notification.* = .{
.listeners = .{},
+ .mem_pool = .empty,
.event_listeners = .{},
.allocator = allocator,
- .mem_pool = .init(allocator),
};
return notification;
@@ -387,7 +387,7 @@ pub fn deinit(self: *Notification) void {
listener.deinit(allocator);
}
self.listeners.deinit(allocator);
- self.mem_pool.deinit();
+ self.mem_pool.deinit(allocator);
allocator.destroy(self);
}
@@ -406,7 +406,7 @@ pub fn register(self: *Notification, comptime event: EventType, receiver: anytyp
}
var list = &@field(self.event_listeners, @tagName(event));
- var listener = try self.mem_pool.create();
+ var listener = try self.mem_pool.create(self.allocator);
errdefer self.mem_pool.destroy(listener);
listener.* = .{
diff --git a/src/Server.zig b/src/Server.zig
index dd91d5163..7bd65a4fb 100644
--- a/src/Server.zig
+++ b/src/Server.zig
@@ -40,7 +40,7 @@ active_threads: std.atomic.Value(u32) = .init(0),
cdps: std.ArrayList(*CDP) = .empty,
cdp_mutex: std.Io.Mutex = .init,
-cdp_pool: std.heap.memory_pool.ExtraManaged(CDP, .{}),
+cdp_pool: std.heap.MemoryPool(CDP),
pub fn init(app: *App, address: sys_net.IpAddress) !*Server {
const self = try app.allocator.create(Server);
@@ -48,11 +48,11 @@ pub fn init(app: *App, address: sys_net.IpAddress) !*Server {
self.* = .{
.app = app,
+ .cdp_pool = .empty,
.json_version_response = "",
- .cdp_pool = .init(app.allocator),
.max_connections = app.config.maxConnections(),
};
- errdefer self.cdp_pool.deinit();
+ errdefer self.cdp_pool.deinit(app.allocator);
// Bind first so /json/version can advertise the OS-assigned port (--port 0).
var bound_address = address;
@@ -87,8 +87,9 @@ pub fn deinit(self: *Server) void {
lp.io.sleep(.fromMilliseconds(10), .awake) catch {};
}
- self.cdps.deinit(self.app.allocator);
- self.cdp_pool.deinit();
+ const allocator = self.app.allocator;
+ self.cdps.deinit(allocator);
+ self.cdp_pool.deinit(allocator);
self.app.allocator.free(self.json_version_response);
self.app.allocator.destroy(self);
}
@@ -177,9 +178,10 @@ fn handleConnection(self: *Server, socket: posix.socket_t) void {
defer _ = std.c.close(socket);
const cdp = blk: {
+ const allocator = self.app.allocator;
self.cdp_mutex.lockUncancelable(lp.io);
defer self.cdp_mutex.unlock(lp.io);
- break :blk self.cdp_pool.create() catch @panic("OOM");
+ break :blk self.cdp_pool.create(allocator) catch @panic("OOM");
};
defer {
self.cdp_mutex.lockUncancelable(lp.io);
diff --git a/src/browser/Browser.zig b/src/browser/Browser.zig
index 5841d46df..ff11177d8 100644
--- a/src/browser/Browser.zig
+++ b/src/browser/Browser.zig
@@ -65,7 +65,7 @@ permissions: std.StringHashMapUnmanaged(PermissionState) = .empty,
viewport_override: ?Viewport = null,
// used by sessions to allocate pages.
-page_pool: std.heap.memory_pool.ExtraManaged(Page, .{}),
+page_pool: std.heap.MemoryPool(Page),
// Registered with App.watchdog for the lifetime of the env. The watchdog
// checker thread reads it until Browser.deinit unregisters.
@@ -77,7 +77,7 @@ watchdog_entry: Watchdog.Entry,
// time up until the Isolate is torn down, so these must outlive every Session.
// Freed in deinit *after* env.deinit() tears down the Isolate — the point past
// which no finalizer can fire.
-fc_identity_pool: std.heap.memory_pool.ExtraManaged(js.FinalizerCallback.Identity, .{}),
+fc_identity_pool: std.heap.MemoryPool(js.FinalizerCallback.Identity),
// Monotonic frame-ID generator scoped to this Browser (one per CDP
// connection). Lives here, not on Session, because CDP target IDs
@@ -113,11 +113,11 @@ pub fn init(self: *Browser, app: *App, opts: InitOpts, cdp: ?*CDP) !void {
.app = app,
.env = env,
.session = null,
+ .page_pool = .empty,
.allocator = allocator,
.arena_pool = &app.arena_pool,
.http_client = undefined,
- .page_pool = .init(allocator),
- .fc_identity_pool = .init(allocator),
+ .fc_identity_pool = .empty,
.selector_cache = .init(allocator),
.watchdog_entry = undefined,
};
@@ -132,6 +132,8 @@ pub fn init(self: *Browser, app: *App, opts: InitOpts, cdp: ?*CDP) !void {
}
pub fn deinit(self: *Browser) void {
+ const allocator = self.allocator;
+
self.closeSession();
// After this returns, the watchdog thread holds no reference to our env
// or http_client — required before either is torn down.
@@ -139,11 +141,11 @@ pub fn deinit(self: *Browser) void {
self.env.deinit();
// After env.deinit() the Isolate is gone, so no further weak finalizer can
// fire — only now is it safe to free the pool backing their parameters.
- self.fc_identity_pool.deinit();
- self.page_pool.deinit();
+ self.fc_identity_pool.deinit(allocator);
+ self.page_pool.deinit(allocator);
self.http_client.deinit();
self.clearPermissions();
- self.permissions.deinit(self.allocator);
+ self.permissions.deinit(allocator);
self.selector_cache.deinit();
}
diff --git a/src/browser/EventManagerBase.zig b/src/browser/EventManagerBase.zig
index 7e6174251..7a98f62d9 100644
--- a/src/browser/EventManagerBase.zig
+++ b/src/browser/EventManagerBase.zig
@@ -55,8 +55,8 @@ const EventKeyContext = struct {
pub const EventManagerBase = @This();
arena: Allocator,
-listener_pool: std.heap.memory_pool.ExtraManaged(Listener, .{}),
-list_pool: std.heap.memory_pool.ExtraManaged(std.DoublyLinkedList, .{}),
+listener_pool: std.heap.MemoryPool(Listener),
+list_pool: std.heap.MemoryPool(std.DoublyLinkedList),
lookup: std.HashMapUnmanaged(
EventKey,
*std.DoublyLinkedList,
@@ -70,8 +70,8 @@ pub fn init(arena: Allocator) EventManagerBase {
return .{
.arena = arena,
.lookup = .{},
- .list_pool = .init(arena),
- .listener_pool = .init(arena),
+ .list_pool = .empty,
+ .listener_pool = .empty,
.dispatch_depth = 0,
.deferred_removals = .empty,
};
@@ -104,6 +104,7 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
.target = target.toString(),
});
}
+ const arena = self.arena;
// If a signal is provided and already aborted, don't register the listener
if (opts.signal) |signal| {
@@ -113,9 +114,9 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
}
// Allocate the type string we'll use in both listener and key
- const type_string = try String.init(self.arena, typ, .{});
+ const type_string = try String.init(arena, typ, .{});
- const gop = try self.lookup.getOrPut(self.arena, .{
+ const gop = try self.lookup.getOrPut(arena, .{
.type_string = type_string,
.event_target = @intFromPtr(target),
});
@@ -138,7 +139,7 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
}
}
} else {
- gop.value_ptr.* = try self.list_pool.create();
+ gop.value_ptr.* = try self.list_pool.create(arena);
gop.value_ptr.*.* = .{};
}
@@ -147,7 +148,7 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
.object => |o| Function{ .object = try o.persist() },
};
- const listener = try self.listener_pool.create();
+ const listener = try self.listener_pool.create(arena);
listener.* = .{
.node = .{},
.once = opts.once,
diff --git a/src/browser/Session.zig b/src/browser/Session.zig
index e3da19902..c3a741a7d 100644
--- a/src/browser/Session.zig
+++ b/src/browser/Session.zig
@@ -268,8 +268,9 @@ pub fn hasPage(self: *const Session) bool {
// Allocate and initialize a Page.
fn allocatePage(self: *Session, frame_id: u32) !*Page {
- const page = try self.browser.page_pool.create();
- errdefer self.browser.page_pool.destroy(page);
+ const browser = self.browser;
+ const page = try browser.page_pool.create(browser.allocator);
+ errdefer browser.page_pool.destroy(page);
try Page.init(page, self, frame_id);
return page;
diff --git a/src/browser/js/Local.zig b/src/browser/js/Local.zig
index f5cdf97be..c5ae2713e 100644
--- a/src/browser/js/Local.zig
+++ b/src/browser/js/Local.zig
@@ -343,7 +343,7 @@ pub fn mapZigInstanceToJs(self: *const Local, js_obj_handle: ?*const v8.Object,
}
const fc = finalizer_gop.value_ptr;
const browser = session.browser;
- const identity_finalizer = try browser.fc_identity_pool.create();
+ const identity_finalizer = try browser.fc_identity_pool.create(browser.allocator);
identity_finalizer.* = .{
.browser = browser,
.page = page,
diff --git a/src/browser/js/js.zig b/src/browser/js/js.zig
index 4649eb0a6..0fbf1fe19 100644
--- a/src/browser/js/js.zig
+++ b/src/browser/js/js.zig
@@ -98,10 +98,10 @@ pub const GlobalSlot = struct {
pub const GlobalTracker = struct {
allocator: Allocator,
list: std.ArrayList(*GlobalSlot) = .empty,
- pool: std.heap.memory_pool.ExtraManaged(GlobalSlot, .{}),
+ pool: std.heap.MemoryPool(GlobalSlot),
pub fn init(allocator: Allocator) GlobalTracker {
- return .{ .allocator = allocator, .pool = .init(allocator) };
+ return .{ .allocator = allocator, .pool = .empty };
}
pub fn deinit(self: *GlobalTracker) void {
@@ -109,18 +109,19 @@ pub const GlobalTracker = struct {
slot.reset();
}
self.list.deinit(self.allocator);
- self.pool.deinit();
+ self.pool.deinit(self.allocator);
}
pub fn track(self: *GlobalTracker, handle: v8.Global) !*GlobalSlot {
- const slot = try self.pool.create();
+ const allocator = self.allocator;
+ const slot = try self.pool.create(allocator);
errdefer self.pool.destroy(slot);
slot.* = .{
.handle = handle,
.tracker = self,
.gindex = @intCast(self.list.items.len),
};
- try self.list.append(self.allocator, slot);
+ try self.list.append(allocator, slot);
return slot;
}
diff --git a/src/cdp/Node.zig b/src/cdp/Node.zig
index 3d27a8fec..8af5f3b23 100644
--- a/src/cdp/Node.zig
+++ b/src/cdp/Node.zig
@@ -39,18 +39,18 @@ pub const Registry = struct {
node_id: u32,
allocator: Allocator,
arena: std.heap.ArenaAllocator,
- node_pool: std.heap.memory_pool.ExtraManaged(Node, .{}),
+ node_pool: std.heap.MemoryPool(Node),
lookup_by_id: std.AutoHashMapUnmanaged(Id, *Node),
lookup_by_node: std.HashMapUnmanaged(*DOMNode, *Node, NodeContext, std.hash_map.default_max_load_percentage),
pub fn init(allocator: Allocator) Registry {
return .{
.node_id = 1,
+ .node_pool = .empty,
.lookup_by_id = .{},
.lookup_by_node = .{},
.allocator = allocator,
.arena = .init(allocator),
- .node_pool = .init(allocator),
};
}
@@ -58,7 +58,7 @@ pub const Registry = struct {
const allocator = self.allocator;
self.lookup_by_id.deinit(allocator);
self.lookup_by_node.deinit(allocator);
- self.node_pool.deinit();
+ self.node_pool.deinit(allocator);
self.arena.deinit();
}
@@ -66,7 +66,7 @@ pub const Registry = struct {
self.lookup_by_id.clearRetainingCapacity();
self.lookup_by_node.clearRetainingCapacity();
_ = self.arena.reset(.{ .retain_with_limit = 1024 });
- _ = self.node_pool.reset(.{ .retain_with_limit = 1024 });
+ _ = self.node_pool.reset(self.allocator, .{ .retain_with_limit = 1024 });
}
/// Evict only the nodes owned by `frame`'s page, leaving sibling pages' node
@@ -99,7 +99,7 @@ pub const Registry = struct {
// but, just in case, let's try to keep things tidy.
errdefer _ = self.lookup_by_node.remove(dom_node);
- const node = try self.node_pool.create();
+ const node = try self.node_pool.create(self.allocator);
errdefer self.node_pool.destroy(node);
const id = self.node_id;
diff --git a/src/network/Network.zig b/src/network/Network.zig
index fc7c827fd..6f50b5ef9 100644
--- a/src/network/Network.zig
+++ b/src/network/Network.zig
@@ -96,7 +96,7 @@ connections: []http.Connection,
available: DoublyLinkedList = .{},
conn_mutex: std.Io.Mutex = .init,
-ws_pool: std.heap.memory_pool.ExtraManaged(http.Connection, .{}),
+ws_pool: std.heap.MemoryPool(http.Connection),
ws_count: usize = 0,
ws_max: u8,
ws_mutex: std.Io.Mutex = .init,
@@ -266,7 +266,7 @@ pub fn init(allocator: Allocator, app: *App, config: *const Config) !Network {
.robot_store = RobotStore.init(allocator),
.web_bot_auth = web_bot_auth,
- .ws_pool = .init(allocator),
+ .ws_pool = .empty,
.ws_max = config.wsMaxConcurrent(),
.ip_filter = ip_filter,
@@ -291,7 +291,7 @@ pub fn deinit(self: *Network) void {
}
self.allocator.free(self.connections);
- self.ws_pool.deinit();
+ self.ws_pool.deinit(self.allocator);
self.robot_store.deinit();
if (self.web_bot_auth) |wba| {
@@ -719,7 +719,7 @@ pub fn newConnection(self: *Network) ?*http.Connection {
return null;
}
- const c = self.ws_pool.create() catch return null;
+ const c = self.ws_pool.create(self.allocator) catch return null;
self.ws_count += 1;
break :blk c;
};