perf(xslt): bound key duplicate checks

Author: gaborbernat

docs/changelog/799.feature.25.rst

@@ -0,0 +1 @@
+Avoid repeated duplicate scans when :class:`~turbohtml.transform.Transform` indexes XSLT keys.

src/turbohtml/_c/query/xslt.c

@@ -320,10 +320,9 @@ typedef struct {
 } nodevec;
 
 static int nodevec_push(nodevec *vec, th_node *node) {
-    for (Py_ssize_t index = 0; index < vec->len; index++) {
-        if (vec->nodes[index] == node) {
-            return 0;
-        }
+    /* build_key processes each source node's values together in document order. */
+    if (vec->len > 0 && vec->nodes[vec->len - 1] == node) {
+        return 0;
     }
     if (vec->len == vec->cap) {
         Py_ssize_t cap = vec->cap == 0 ? 4 : vec->cap * 2;

tests/convert/test_transform.py

@@ -792,6 +792,62 @@ def test_transform_key_deduplicates_a_node_under_one_value() -> None:
     assert _run("<r><i><t>same</t><t>same</t></i></r>", body) == "1"
 
 
+@pytest.mark.parametrize(
+    ("match", "use", "source", "wanted", "expected"),
+    [
+        pytest.param("i", "'same'", '<r><i id="a"/><i id="b"/><i id="c"/></r>', "same", "abc", id="scalar-key"),
+        pytest.param(
+            "i",
+            "t",
+            '<r><i id="a"><t>x</t><t>y</t><t>x</t></i><i id="b"><t>x</t><t>x</t></i></r>',
+            "x",
+            "ab",
+            id="interleaved-use-values",
+        ),
+        pytest.param(
+            "i",
+            "@a | @b",
+            '<r><i id="a" a="x" b="x"/><i id="b" a="x" b="y"/></r>',
+            "x",
+            "ab",
+            id="duplicate-attribute-values",
+        ),
+        pytest.param(
+            "/r/i | /r/i/@a | /r/i/@b",
+            "'same'",
+            '<r><i id="a" a="x" b="y"/><i id="b" a="x" b="y"/></r>',
+            "same",
+            "ab",
+            id="element-and-attribute-match-owners",
+        ),
+        pytest.param(
+            "id('c a b a')",
+            "'same'",
+            '<r><i id="a"/><i id="b"/><i id="c"/></r>',
+            "same",
+            "abc",
+            id="id-pattern-order-and-duplicates",
+        ),
+        pytest.param("i", "t", '<r><i id="a"/><i id="b"><t>x</t></i></r>', "x", "b", id="empty-use-node-set"),
+        pytest.param(
+            "i",
+            "t",
+            '<r><i id="a"><t/></i><i id="b"><t/><t/></i></r>',
+            "",
+            "ab",
+            id="empty-key-string",
+        ),
+    ],
+)
+def test_transform_key_bucket_duplicate_order(match: str, use: str, source: str, wanted: str, expected: str) -> None:
+    body: Final = (
+        f'<xsl:key name="k" match="{match}" use="{use}"/>'
+        f'<xsl:template match="/"><xsl:for-each select="key(&quot;k&quot;,&quot;{wanted}&quot;)">'
+        '<xsl:value-of select="@id"/></xsl:for-each></xsl:template>'
+    )
+    assert _run(source, body) == expected
+
+
 def test_transform_key_string_use_expression() -> None:
     body = (
         '<xsl:key name="k" match="i" use="string(@n)"/>'

tools/bench/ci.py

@@ -429,6 +429,11 @@ def _book_html() -> str:
     "normalize-marks-large": ("normalize-marks", 2),
     "normalize-marks-small": ("normalize-marks", 0),
     "normalize-hebrew-marks": ("normalize", 8),
+    "transform-key": ("transform-key", 0),
+    "transform-key-attribute": ("transform-key", 1),
+    "transform-key-repeated": ("transform-key", 2),
+    "transform-key-unique": ("transform-key", 3),
+    "transform-key-small": ("transform-key", 4),
 }
 
 

tools/bench/core.py

@@ -1704,6 +1704,7 @@ def _query_root_group_case(case: tuple[str, int]) -> _Query:
     "transform-names-compile": (transform_compile, "turbohtml"),
     "transform-reuse": (transform_reuse, "turbohtml"),
     "transform-sort": (transform, "turbohtml"),
+    "transform-key": (transform, "turbohtml"),
     "transform-dense": (transform, "turbohtml"),
     "transform-number": (transform, "turbohtml"),
     "transform-rules": (transform, "turbohtml"),

tools/bench/operations.py

@@ -494,6 +494,7 @@ class Operation:
     "transform-compile": Operation("compile an XSLT stylesheet with 300 templates", "us"),
     "transform-reuse": Operation("apply one compiled 300-template stylesheet ten times", "us"),
     "transform-sort": Operation("XSLT sort node sets", "ms"),
+    "transform-key": Operation("build XSLT key indexes", "us"),
     "transform-dense": Operation("XSLT transform an instruction-dense sheet", "us"),
     "transform-names-compile": Operation("compile XSLT declaration indexes", "us"),
     "transform-names": Operation("resolve XSLT declaration names", "us"),
@@ -1043,6 +1044,30 @@ def _transform_text_cases() -> tuple[tuple[str, object], ...]:
     return tuple(cases)
 
 
+def _transform_key_cases() -> tuple[tuple[str, object], ...]:
+    return tuple(
+        (
+            f"{label} ({count:,} nodes)",
+            (
+                (
+                    '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">'
+                    f'<xsl:key name="k" match="i" use="{use}"/><xsl:output method="text"/>'
+                    f'<xsl:template match="/"><xsl:value-of select="count(key(&quot;k&quot;,&quot;{wanted}&quot;))"/>'
+                    "</xsl:template></xsl:stylesheet>"
+                ),
+                "<r>" + "".join(item.format(index=index) for index in range(count)) + "</r>",
+            ),
+        )
+        for label, use, wanted, item, count in (
+            ("shared scalar key", "'same'", "same", "<i/>", 8192),
+            ("shared attribute key", "@key", "same", '<i key="same"/>', 8192),
+            ("repeated node-set keys", "t", "same", "<i><t>same</t><t>other</t><t>same</t></i>", 2048),
+            ("unique keys", "@key", "k0", '<i key="k{index}"/>', 8192),
+            ("small shared key", "'same'", "same", "<i/>", 4),
+        )
+    )
+
+
 def _transform_cases() -> tuple[tuple[str, object], ...]:
     """Return the one XSLT case: a real stylesheet (sort, key, number, format-number) over a 120-row catalog."""
     return (("catalog (120 rows)", (_XSLT_SHEET, _XSLT_SOURCE)),)
@@ -2401,6 +2426,7 @@ def _encoding_result_cases() -> tuple[tuple[str, bytes], ...]:
     "transform-compile": _transform_compile_cases,
     "transform-reuse": _transform_compile_cases,
     "transform-sort": _transform_sort_cases,
+    "transform-key": _transform_key_cases,
     "transform-dense": _transform_dense_cases,
     "transform-names": _transform_name_cases,
     "transform-names-compile": lambda: (_transform_name_cases()[0],),