Skip to content

Lightpanda: the headless browser designed for AI and automation

perf(css): cache parsed selectors per frame

Adrià Arrufat05b6eaf82c39
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 4f0207366..d8d290c0a 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -52,6 +52,7 @@ 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");
@@ -120,6 +121,10 @@ _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 4e9df2272..dbe54d8b3 100644
--- a/src/browser/webapi/selector/Selector.zig
+++ b/src/browser/webapi/selector/Selector.zig
@@ -51,22 +51,43 @@ pub fn parseLeaky(arena: Allocator, input: []const u8) !Parsed {
return .{ .selectors = try Parser.parseList(arena, input) };
}
+// SelectorPath synthesizes many one-off selectors, so past the cap we parse
+// into a per-call arena rather than grow the frame-lifetime cache unbounded.
+const max_cache_entries = 1024;
+
+/// 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. `fallback` backs the parse once the cache is full.
+fn cachedParse(frame: *Frame, fallback: Allocator, input: []const u8) ![]const Selector {
+ if (input.len == 0) {
+ return error.SyntaxError;
+ }
+ if (frame._selector_cache.get(input)) |selectors| {
+ return selectors;
+ }
+ if (frame._selector_cache.count() >= max_cache_entries) {
+ return Parser.parseList(fallback, input);
+ }
+
+ const arena = frame.arena;
+ const owned = try arena.dupe(u8, input);
+ const selectors = try Parser.parseList(arena, owned);
+ try frame._selector_cache.put(arena, owned, selectors);
+ return selectors;
+}
+
pub fn querySelector(root: *Node, input: []const u8, frame: *Frame) !?*Node.Element {
- const parsed = try parseLeaky(frame.call_arena, input);
+ const parsed = Parsed{ .selectors = try cachedParse(frame, frame.call_arena, input) };
return parsed.query(root, frame);
}
pub fn querySelectorAll(root: *Node, input: []const u8, frame: *Frame) !*List {
- if (input.len == 0) {
- return error.SyntaxError;
- }
-
const arena = try frame.getArena(.small, "querySelectorAll");
errdefer frame.releaseArena(arena);
var nodes: std.AutoArrayHashMapUnmanaged(*Node, void) = .empty;
- const selectors = try Parser.parseList(arena, input);
+ const selectors = try cachedParse(frame, arena, input);
for (selectors) |selector| {
try List.collect(arena, root, selector, &nodes, frame);
}
@@ -80,12 +101,7 @@ pub fn querySelectorAll(root: *Node, input: []const u8, frame: *Frame) !*List {
}
pub fn matches(el: *Node.Element, input: []const u8, frame: *Frame) !bool {
- if (input.len == 0) {
- return error.SyntaxError;
- }
-
- const arena = frame.call_arena;
- const selectors = try Parser.parseList(arena, input);
+ const selectors = try cachedParse(frame, frame.call_arena, input);
for (selectors) |selector| {
if (List.matches(el.asNode(), selector, el.asNode(), frame)) {
@@ -98,12 +114,7 @@ pub fn matches(el: *Node.Element, input: []const u8, frame: *Frame) !bool {
// Like matches, but allows the caller to specify a scope node distinct from el.
// Used by closest() so that :scope always refers to the original context element.
pub fn matchesWithScope(el: *Node.Element, input: []const u8, scope: *Node.Element, frame: *Frame) !bool {
- if (input.len == 0) {
- return error.SyntaxError;
- }
-
- const arena = frame.call_arena;
- const selectors = try Parser.parseList(arena, input);
+ const selectors = try cachedParse(frame, frame.call_arena, input);
for (selectors) |selector| {
if (List.matches(el.asNode(), selector, scope.asNode(), frame)) {