Skip to content

Lightpanda: the headless browser designed for AI and automation

perf(css): move selector cache to Browser with bounded eviction

Adrià Arrufatc04d316f8a2e
diff --git a/src/browser/Browser.zig b/src/browser/Browser.zig
index 62652b1d5..23926ccf6 100644
--- a/src/browser/Browser.zig
+++ b/src/browser/Browser.zig
@@ -25,6 +25,7 @@ const Notification = @import("../Notification.zig");
const js = @import("js/js.zig");
const Page = @import("Page.zig");
const Session = @import("Session.zig");
+const Selector = @import("webapi/selector/Selector.zig");
const Viewport = @import("Viewport.zig");
const HttpClient = @import("HttpClient.zig");
const PermissionState = @import("webapi/Permissions.zig").State;
@@ -44,6 +45,9 @@ allocator: Allocator,
arena_pool: *ArenaPool,
http_client: HttpClient,
+// Shared across pages, survives navigation. See Selector.Cache.
+selector_cache: Selector.Cache,
+
// Permission state set via CDP Browser.grantPermissions / setPermission /
// resetPermissions, keyed by permission name (e.g. "geolocation"). Read back
// by navigator.permissions.query(). Scoped to the Browser so it persists
@@ -109,6 +113,7 @@ pub fn init(self: *Browser, app: *App, opts: InitOpts, cdp: ?*CDP) !void {
.http_client = undefined,
.page_pool = std.heap.MemoryPool(Page).init(allocator),
.fc_identity_pool = .init(allocator),
+ .selector_cache = .init(allocator),
};
try self.http_client.init(allocator, &app.network, cdp);
}
@@ -123,6 +128,7 @@ pub fn deinit(self: *Browser) void {
self.http_client.deinit();
self.clearPermissions();
self.permissions.deinit(self.allocator);
+ self.selector_cache.deinit();
}
// Set (or overwrite) the stored state for a permission. The name is duped into
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index d8d290c0a..4f0207366 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -52,7 +52,6 @@ const VisualViewport = @import("webapi/VisualViewport.zig");
const AbstractRange = @import("webapi/AbstractRange.zig");
const Worker = @import("webapi/Worker.zig");
const CSSStyleSheet = @import("webapi/css/CSSStyleSheet.zig");
-const Selector = @import("webapi/selector/Selector.zig");
const CustomElementDefinition = @import("webapi/CustomElementDefinition.zig");
const PageTransitionEvent = @import("webapi/event/PageTransitionEvent.zig");
const SubmitEvent = @import("webapi/event/SubmitEvent.zig");
@@ -121,10 +120,6 @@ _attribute_named_node_map_lookup: std.AutoHashMapUnmanaged(usize, *Element.Attri
// that actually access these features via JavaScript, saving 24 bytes per element.
_element_styles: Element.StyleLookup = .empty,
_element_datasets: Element.DatasetLookup = .empty,
-
-// Keyed by selector string. The parsed AST borrows slices of the key, so both
-// live on `arena` (frame lifetime). See Selector.cachedParse.
-_selector_cache: std.StringHashMapUnmanaged([]const Selector.Selector) = .empty,
_element_class_lists: Element.ClassListLookup = .empty,
_element_rel_lists: Element.RelListLookup = .empty,
_element_shadow_roots: Element.ShadowRootLookup = .empty,
diff --git a/src/browser/webapi/selector/Selector.zig b/src/browser/webapi/selector/Selector.zig
index 9a3b9d3c2..0fae181cb 100644
--- a/src/browser/webapi/selector/Selector.zig
+++ b/src/browser/webapi/selector/Selector.zig
@@ -51,24 +51,66 @@ pub fn parseLeaky(arena: Allocator, input: []const u8) !Parsed {
return .{ .selectors = try Parser.parseList(arena, input) };
}
-/// Parse `input` via the frame's selector cache. The parsed AST borrows slices
-/// of its input, so on a miss the key is duped into `frame.arena` and parsed
-/// against that copy; both share the frame's lifetime. Only for selectors that
-/// recur (page scripts, waitForSelector) — one-off synthesized selectors use the
-/// `*Uncached` variants so they don't pollute a frame-lifetime cache.
+/// One-off synthesized selectors use the `*Uncached` variants instead.
fn cachedParse(frame: *Frame, input: []const u8) ![]const Selector {
- if (input.len == 0) {
- return error.SyntaxError;
+ return frame._session.browser.selector_cache.parse(input);
+}
+
+/// On the Browser because a parsed selector references no Frame/Context, so
+/// entries survive navigation. Per-entry arena so eviction can free one entry.
+pub const Cache = struct {
+ // Caps retained memory, not correctness; oldest entry evicted on overflow.
+ const max_entries = 1024;
+
+ allocator: Allocator,
+ map: std.StringArrayHashMapUnmanaged(Entry) = .empty,
+
+ const Entry = struct {
+ arena: std.heap.ArenaAllocator,
+ selectors: []const Selector,
+ };
+
+ pub fn init(allocator: Allocator) Cache {
+ return .{ .allocator = allocator };
+ }
+
+ pub fn deinit(self: *Cache) void {
+ for (self.map.values()) |*entry| {
+ entry.arena.deinit();
+ }
+ self.map.deinit(self.allocator);
}
- if (frame._selector_cache.get(input)) |selectors| {
+
+ fn parse(self: *Cache, input: []const u8) ![]const Selector {
+ if (input.len == 0) {
+ return error.SyntaxError;
+ }
+ if (self.map.get(input)) |entry| {
+ return entry.selectors;
+ }
+
+ // The AST borrows slices of its input, so dupe the key into the arena.
+ var arena = std.heap.ArenaAllocator.init(self.allocator);
+ errdefer arena.deinit();
+ const entry_arena = arena.allocator();
+ const owned = try entry_arena.dupe(u8, input);
+ const selectors = try Parser.parseList(entry_arena, owned);
+
+ if (self.map.count() >= max_entries) {
+ self.evictOldest();
+ }
+ try self.map.put(self.allocator, owned, .{ .arena = arena, .selectors = selectors });
return selectors;
}
- const owned = try frame.arena.dupe(u8, input);
- const selectors = try Parser.parseList(frame.arena, owned);
- try frame._selector_cache.put(frame.arena, owned, selectors);
- return selectors;
-}
+ // Insertion order is preserved, so index 0 is the oldest.
+ fn evictOldest(self: *Cache) void {
+ const key = self.map.keys()[0];
+ var arena = self.map.values()[0].arena;
+ std.debug.assert(self.map.orderedRemove(key));
+ arena.deinit();
+ }
+};
fn collectAll(arena: Allocator, selectors: []const Selector, root: *Node, frame: *Frame) !*List {
var nodes: std.AutoArrayHashMapUnmanaged(*Node, void) = .empty;