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.zigindex 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 intodiff --git a/src/browser/Frame.zig b/src/browser/Frame.zigindex 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.zigindex 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;