python-zeroconf
diff --git a/‎tests/benchmarks/test_cache_mark_expire.py‎
Lines changed: 71 additions & 70 deletions b/‎tests/benchmarks/test_cache_mark_expire.py‎
Lines changed: 71 additions & 70 deletions
@@ -1,14 +1,17 @@
 """Benchmarks for DNSCache.async_mark_unique_records_older_than_1s_to_expire.
 
-Covers the RFC 6762 §10.2 paragraph 2 path that marks superseded unique
-records to expire in 1s. Today it mutates cached records in place via
-``DNSRecord._set_created_ttl`` (see ``_cache.py`` line ~345). These
-benchmarks pin the cost of the current path so a copy-instead-of-mutate
-follow-up (issue #1780) has a baseline to compare against.
+Covers the RFC 6762 §10.2 paragraph 2 path. ``_async_set_created_ttl``
+mutates cached records in place, so a repeated-iteration benchmark
+would only measure work on the first call. Each test uses
+``benchmark.pedantic`` with a per-round ``setup`` that rebuilds the
+stale cache; the ``async_add_records`` cost stays outside the timed
+window.
 """
 
 from __future__ import annotations
 
+from typing import Any
+
 from pytest_codspeed import BenchmarkFixture
 
 from zeroconf import DNSAddress, DNSCache, DNSPointer, current_time_millis
@@ -22,89 +25,69 @@ def _ipv4_bytes(i: int) -> bytes:
 
 
 def test_mark_to_expire_1000_records_all_stale(benchmark: BenchmarkFixture) -> None:
-    """Worst-case mark-to-expire: every cached record needs mutation.
-
-    1000 unique A records, all created > 1s ago, none in the new answer
-    set — every iteration hits the ``_async_set_created_ttl`` path.
-    """
+    """Worst-case mark-to-expire: 1000 stale unique A records, all mutated."""
     now = current_time_millis()
     name = "stale.local."
-    cache = DNSCache()
-    cache.async_add_records(
-        DNSAddress(
-            name,
-            _TYPE_A,
-            _UNIQUE_CLASS,
-            120,
-            _ipv4_bytes(i),
-            created=now - 5_000,
-        )
-        for i in range(1000)
-    )
     unique_types = {(name, _TYPE_A, _UNIQUE_CLASS)}
-    # An unrelated answer keeps every cached record in the "must expire"
+    # Unrelated answer keeps every cached record in the "must expire"
     # branch (no membership hit short-circuits the mutation).
     answers = [DNSAddress(name, _TYPE_A, _UNIQUE_CLASS, 120, _ipv4_bytes(0xDEAD_BEEF))]
 
-    @benchmark
-    def _mark() -> None:
+    def _setup() -> tuple[tuple[Any, ...], dict[str, Any]]:
+        cache = DNSCache()
+        cache.async_add_records(
+            DNSAddress(
+                name,
+                _TYPE_A,
+                _UNIQUE_CLASS,
+                120,
+                _ipv4_bytes(i),
+                created=now - 5_000,
+            )
+            for i in range(1000)
+        )
+        return (cache,), {}
+
+    def _mark(cache: DNSCache) -> None:
         cache.async_mark_unique_records_older_than_1s_to_expire(unique_types, answers, now)
 
+    benchmark.pedantic(_mark, setup=_setup)
 
-def test_mark_to_expire_1000_records_none_stale(benchmark: BenchmarkFixture) -> None:
-    """Same shape, but every record is fresh (created < 1s ago).
 
-    Measures the scan + age-check overhead without paying any
-    ``_async_set_created_ttl`` cost. The delta to the all-stale case is
-    the mutation+re-add tax we'd avoid by switching to copy-on-expire.
-    """
+def test_mark_to_expire_1000_records_none_stale(benchmark: BenchmarkFixture) -> None:
+    """Scan-only path: 1000 fresh records, no mutation."""
     now = current_time_millis()
     name = "fresh.local."
-    cache = DNSCache()
-    cache.async_add_records(
-        DNSAddress(
-            name,
-            _TYPE_A,
-            _UNIQUE_CLASS,
-            120,
-            _ipv4_bytes(i),
-            created=now,
-        )
-        for i in range(1000)
-    )
     unique_types = {(name, _TYPE_A, _UNIQUE_CLASS)}
     answers = [DNSAddress(name, _TYPE_A, _UNIQUE_CLASS, 120, _ipv4_bytes(0xDEAD_BEEF))]
 
-    @benchmark
-    def _mark() -> None:
+    def _setup() -> tuple[tuple[Any, ...], dict[str, Any]]:
+        cache = DNSCache()
+        cache.async_add_records(
+            DNSAddress(
+                name,
+                _TYPE_A,
+                _UNIQUE_CLASS,
+                120,
+                _ipv4_bytes(i),
+                created=now,
+            )
+            for i in range(1000)
+        )
+        return (cache,), {}
+
+    def _mark(cache: DNSCache) -> None:
         cache.async_mark_unique_records_older_than_1s_to_expire(unique_types, answers, now)
 
+    benchmark.pedantic(_mark, setup=_setup)
 
-def test_mark_to_expire_many_unique_types(benchmark: BenchmarkFixture) -> None:
-    """Many distinct (name, type, class) triplets, one stale record each.
 
-    Mirrors a burst response that supersedes 100 different unique RRsets
-    in one packet — the outer loop dominates, but each inner iteration
-    still triggers in-place mutation.
-    """
+def test_mark_to_expire_many_unique_types(benchmark: BenchmarkFixture) -> None:
+    """100 distinct (name, type, class) triplets, one stale record each."""
     now = current_time_millis()
-    cache = DNSCache()
-    unique_types: set[tuple[str, int, int]] = set()
-    for i in range(100):
-        name = f"svc{i}.local."
-        cache.async_add_records(
-            [
-                DNSPointer(
-                    name,
-                    _TYPE_PTR,
-                    _UNIQUE_CLASS,
-                    120,
-                    f"target{i}.local.",
-                    created=now - 5_000,
-                )
-            ]
-        )
-        unique_types.add((name, _TYPE_PTR, _UNIQUE_CLASS))
+    unique_types: set[tuple[str, int, int]] = {
+        (f"svc{i}.local.", _TYPE_PTR, _UNIQUE_CLASS) for i in range(100)
+    }
     # New answers reference a different alias, so the cached entries are
     # not equal to anything in ``answers_rrset`` and must be expired.
     answers = [
@@ -118,6 +101,24 @@ def test_mark_to_expire_many_unique_types(benchmark: BenchmarkFixture) -> None:
         for i in range(100)
     ]
 
-    @benchmark
-    def _mark() -> None:
+    def _setup() -> tuple[tuple[Any, ...], dict[str, Any]]:
+        cache = DNSCache()
+        for i in range(100):
+            cache.async_add_records(
+                [
+                    DNSPointer(
+                        f"svc{i}.local.",
+                        _TYPE_PTR,
+                        _UNIQUE_CLASS,
+                        120,
+                        f"target{i}.local.",
+                        created=now - 5_000,
+                    )
+                ]
+            )
+        return (cache,), {}
+
+    def _mark(cache: DNSCache) -> None:
         cache.async_mark_unique_records_older_than_1s_to_expire(unique_types, answers, now)
+
+    benchmark.pedantic(_mark, setup=_setup)