Lightpanda: the headless browser designed for AI and automation
mem: optimize node child list
Karl Seguin3bf98a33fdb9
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zigindex cdb864359..5d40c591e 100644--- a/src/browser/Frame.zig+++ b/src/browser/Frame.zig@@ -2458,20 +2458,13 @@ pub fn removeNode(self: *Frame, parent: *Node, child: *Node, opts: RemoveNodeOptelsenull;- const children = parent._children.?;- children.remove(&child._child_link);- if (children.first == null) {- // last child removed; drop the list so a childless node holds no allocation- parent._children = null;- self._factory.destroy(children);- }+ parent.unlink(child);// grab this before we null the parentconst was_connected = child.isConnected();// Capture the ID map before disconnecting, so we can remove IDs from the correct documentconst id_maps = if (was_connected) self.getElementIdMap(child) else null;child._parent = null;- child._child_link = .{};// Update live ranges for removal (DOM spec remove steps 4-7)if (child_index_for_ranges) |idx| {@@ -2631,23 +2624,17 @@ pub fn _insertNodeRelative(self: *Frame, comptime from_parser: bool, parent: *Nolp.assert(child._parent == null, "Frame.insertNodeRelative parent", .{});- const children = parent._children orelse blk: {- const list = try self._factory.create(std.DoublyLinkedList{});- parent._children = list;- break :blk list;- };-switch (relative) {- .append => children.append(&child._child_link),+ .append => parent.linkLast(child),.after => |ref_node| {// caller should have made sure this was the caselp.assert(ref_node._parent.? == parent, "Frame.insertNodeRelative after", .{ .url = self.url });- children.insertAfter(&ref_node._child_link, &child._child_link);+ parent.linkAfter(ref_node, child);},.before => |ref_node| {// caller should have made sure this was the caselp.assert(ref_node._parent.? == parent, "Frame.insertNodeRelative before", .{ .url = self.url });- children.insertBefore(&ref_node._child_link, &child._child_link);+ parent.linkBefore(ref_node, child);},}child._parent = parent;diff --git a/src/browser/frame/parse.zig b/src/browser/frame/parse.zigindex 526fc872d..aa690755c 100644--- a/src/browser/frame/parse.zig+++ b/src/browser/frame/parse.zig@@ -80,12 +80,15 @@ fn htmlAsChildrenInner(frame: *Frame, node: *Node, html: []const u8, opts: Fragm// Because of custom element callbacks, the structure might not be what// we expect, and nodes might be altogether removed. We deal with this in a// few different places, but always the same way: leave it as-is.- const children = node._children orelse return;- const first = Node.linkToNode(children.first.?);+ const first = node.firstChild() orelse return;if (first.is(Element.Html.Html) == null) {return;}- node._children = first._children;+ node._first_child = first._first_child;+ first._first_child = null;+ first._parent = null;+ first._prev = null;+ first._next = null;// No mutation records for the unwrapped children either; see the comment// about fragment parses in _insertNodeRelative.diff --git a/src/browser/webapi/DOMNodeIterator.zig b/src/browser/webapi/DOMNodeIterator.zigindex b2336bb31..1686e054e 100644--- a/src/browser/webapi/DOMNodeIterator.zig+++ b/src/browser/webapi/DOMNodeIterator.zig@@ -215,8 +215,8 @@ fn filterNode(self: *const DOMNodeIterator, node: *Node, frame: *Frame) !i32 {fn getNextInTree(self: *const DOMNodeIterator, node: *Node) ?*Node {// Depth-first traversal within the root subtree- if (node._children) |children| {- return Node.linkToNode(children.first.?);+ if (node.firstChild()) |first| {+ return first;}var current = node;diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zigindex 6a4712408..aaef3fce4 100644--- a/src/browser/webapi/Document.zig+++ b/src/browser/webapi/Document.zig@@ -1061,8 +1061,7 @@ fn writeInternal(self: *Document, text: []const []const u8, append_newline: bool// Extract children from wrapper HTML element (html5ever wraps fragments)// https://github.com/servo/html5ever/issues/583- const children = fragment_node._children orelse return;- const first = Node.linkToNode(children.first.?);+ const first = fragment_node.firstChild() orelse return;// Collect all children to insert (to avoid iterator invalidation)var children_to_insert: std.ArrayList(*Node) = .empty;@@ -1472,7 +1471,7 @@ pub fn injectBlank(self: *Document, frame: *Frame) error{InjectBlankError}!voidfn _injectBlank(self: *Document, frame: *Frame) !void {if (comptime IS_DEBUG) {// should only be called on an empty document- std.debug.assert(self.asNode()._children == null);+ std.debug.assert(self.asNode()._first_child == null);}const html = try Frame.node_factory.createElementNS(frame, .html, "html", null);diff --git a/src/browser/webapi/Node.zig b/src/browser/webapi/Node.zigindex 0bd37dbcc..2519df1a6 100644--- a/src/browser/webapi/Node.zig+++ b/src/browser/webapi/Node.zig@@ -37,7 +37,6 @@ pub const ShadowRoot = @import("ShadowRoot.zig");const String = lp.String;const Allocator = std.mem.Allocator;-const LinkedList = std.DoublyLinkedList;pub const AssignedSlotLookup = std.AutoHashMapUnmanaged(*Node, *Element.Html.Slot);@@ -46,10 +45,11 @@ const Node = @This();_type: Type,_proto: *EventTarget,_parent: ?*Node = null,-// A node with no children leaves this null (no allocation). Otherwise it-// points to a heap-allocated intrusive list of the node's `_child_link`s.-_children: ?*LinkedList = null,-_child_link: LinkedList.Node = .{},+// The first child's `_prev` points at the LAST child (keeping lastChild+// O(1)); the last child's `_next` is null. A detached node has null links.+_first_child: ?*Node = null,+_next: ?*Node = null,+_prev: ?*Node = null,// Lookup for nodes that have a different owner document than frame.documentpub const OwnerDocumentLookup = std.AutoHashMapUnmanaged(*Node, *Document);@@ -178,21 +178,25 @@ fn adjacentParent(self: *Node, variant: AdjacentVariant) !*Node {}pub fn firstChild(self: *const Node) ?*Node {- const children = self._children orelse return null;- return linkToNodeOrNull(children.first);+ return self._first_child;}pub fn lastChild(self: *const Node) ?*Node {- const children = self._children orelse return null;- return linkToNodeOrNull(children.last);+ const first = self._first_child orelse return null;+ return first._prev;}pub fn nextSibling(self: *const Node) ?*Node {- return linkToNodeOrNull(self._child_link.next);+ return self._next;}pub fn previousSibling(self: *const Node) ?*Node {- return linkToNodeOrNull(self._child_link.prev);+ const parent = self._parent orelse return null;+ if (parent._first_child == self) {+ // our _prev points at the parent's last child+ return null;+ }+ return self._prev;}pub fn parentNode(self: *const Node) ?*Node {@@ -1074,13 +1078,7 @@ pub fn format(self: *Node, writer: *std.Io.Writer) !void {// Returns an iterator the can be used to iterate through the node's children// For internal use.pub fn childrenIterator(self: *Node) NodeIterator {- const children = self._children orelse {- return .{ .node = null };- };-- return .{- .node = linkToNodeOrNull(children.first),- };+ return .{ .node = self._first_child };}pub fn getChildrenCount(self: *Node) usize {@@ -1322,13 +1320,11 @@ pub fn compareDocumentPosition(self: *Node, other: *Node) u16 {return DISCONNECTED;}-// faster to compare the linked list node links directlyfn isNodeBefore(node1: *const Node, node2: *const Node) bool {- var current = node1._child_link.next;- const target = &node2._child_link;- while (current) |link| {- if (link == target) return true;- current = link.next;+ var current = node1._next;+ while (current) |n| {+ if (n == node2) return true;+ current = n._next;}return false;}@@ -1587,18 +1583,70 @@ const NodeIterator = struct {node: ?*Node,pub fn next(self: *NodeIterator) ?*Node {const node = self.node orelse return null;- self.node = linkToNodeOrNull(node._child_link.next);+ self.node = node._next;return node;}};-// Turns a linked list node into a Node-pub fn linkToNode(n: *LinkedList.Node) *Node {- return @fieldParentPtr("_child_link", n);+// Low-level sibling-list splicing, used by Frame's insert/remove. These only+// maintain the link invariants (first child's `_prev` is the last child, last+// child's `_next` is null); the caller handles `_parent` and all DOM+// bookkeeping.+pub fn linkLast(self: *Node, child: *Node) void {+ child._next = null;+ if (self._first_child) |first| {+ const last = first._prev.?;+ last._next = child;+ child._prev = last;+ first._prev = child;+ } else {+ self._first_child = child;+ child._prev = child;+ }+}++pub fn linkBefore(self: *Node, ref: *Node, child: *Node) void {+ child._next = ref;+ child._prev = ref._prev;+ if (self._first_child == ref) {+ self._first_child = child;+ } else {+ ref._prev.?._next = child;+ }+ ref._prev = child;+}++pub fn linkAfter(self: *Node, ref: *Node, child: *Node) void {+ child._prev = ref;+ child._next = ref._next;+ if (ref._next) |next| {+ next._prev = child;+ } else {+ // ref was the last child+ self._first_child.?._prev = child;+ }+ ref._next = child;}-pub fn linkToNodeOrNull(n_: ?*LinkedList.Node) ?*Node {- return if (n_) |n| linkToNode(n) else null;+pub fn unlink(self: *Node, child: *Node) void {+ const first = self._first_child.?;+ if (child == first) {+ if (child._next) |next| {+ next._prev = child._prev;+ self._first_child = next;+ } else {+ self._first_child = null;+ }+ } else {+ child._prev.?._next = child._next;+ if (child._next) |next| {+ next._prev = child._prev;+ } else {+ first._prev = child._prev;+ }+ }+ child._next = null;+ child._prev = null;}pub const JsApi = struct {diff --git a/src/browser/webapi/collections/ChildNodes.zig b/src/browser/webapi/collections/ChildNodes.zigindex 08e4096ae..176497593 100644--- a/src/browser/webapi/collections/ChildNodes.zig+++ b/src/browser/webapi/collections/ChildNodes.zig@@ -32,7 +32,7 @@ const ChildNodes = @This();_arena: std.mem.Allocator,_last_index: usize,_last_length: ?u32,-_last_node: ?*std.DoublyLinkedList.Node,+_last_node: ?*Node,_cached_version: usize,_node: *Node,@@ -66,10 +66,12 @@ pub fn length(self: *ChildNodes, frame: *const Frame) !u32 {return cached_length;}}- const children = self._node._children orelse return 0;-// O(N)- const len: u32 = @intCast(children.len());+ var len: u32 = 0;+ var it = self._node.childrenIterator();+ while (it.next()) |_| {+ len += 1;+ }self._last_length = len;return len;}@@ -78,7 +80,7 @@ pub fn getAtIndex(self: *ChildNodes, index: usize, frame: *const Frame) !?*Node_ = self.versionCheck(frame);var current = self._last_index;- var node: ?*std.DoublyLinkedList.Node = null;+ var node: ?*Node = null;if (index < current or self._last_node == null) {current = 0;node = self.first() orelse return null;@@ -90,17 +92,17 @@ pub fn getAtIndex(self: *ChildNodes, index: usize, frame: *const Frame) !?*Nodewhile (node) |n| {if (index == current) {self._last_node = n;- return Node.linkToNode(n);+ return n;}current += 1;- node = n.next;+ node = n.nextSibling();}self._last_node = null;return null;}-pub fn first(self: *const ChildNodes) ?*std.DoublyLinkedList.Node {- return (self._node._children orelse return null).first;+pub fn first(self: *const ChildNodes) ?*Node {+ return self._node.firstChild();}pub fn keys(self: *ChildNodes, frame: *Frame) !*KeyIterator {