pytest-timing 0.3.0__tar.gz → 0.3.1__tar.gz

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/ARCHITECTURE.md

@@ -388,27 +388,45 @@ happens only when nothing runs in the domain, so nothing else's memory is at ris
 Pressure feedback moves only the CPU limit.
 
 Demand comes from history, never from declarations. `Estimates.from_run` keeps, per
-test, the largest `peak - base` any attempt showed (the worst case is what an
-out-of-memory kill depends on), and per shared fixture key the memory the attempt that
-paid its set-up kept resident (`after - base`, split evenly when one attempt paid for
-several). `Costs.charge` adds a `memory` to each `Charge`: the test's rise plus what
-the fixtures alive around it keep, projected through the lane's fixture state exactly
-as CPU holds are, since workers report nothing about memory at run time. A fixture with
-recorded memory belongs to its tests' families even when its set-up was too quick to
-matter for time. `_need_memory` is the twin of `_need`; an idle worker reserves what
-its fixtures keep, and a worker whose next test could never fit next to what the
-other workers' fixtures keep is parked like one blocked by CPU holds. A fixture
-reached at run time adds its recorded memory to the queued charges when its
-request is granted.
+test, the largest need any attempt showed (the worst case is what an out-of-memory
+kill depends on), and per shared fixture key the memory the attempt that paid its
+set-up kept resident (`after - base`, split evenly when one attempt paid for
+several). A payer's rise spans its set-ups, so its own need is `peak - after`: what
+it used beyond what stayed, which is the fixtures'. Session- and package-scoped
+fixtures are the exception: what they keep is every worker's baseline
+(`is_baseline`), never attributed, charged or projected. Every worker sets them up
+once and never lets go, so gating on them cannot spare the host; it can only hold
+tests back, or park a worker until stall resolution shuts it down, which is what a
+large session fixture did before this rule. The first attempt on each worker is a
+warm-up window (lazy imports, caches, the allocator's first growth), so its rise and
+residual count only for a test or fixture with no other attempt.
+
+`Costs.charge` adds a `memory` to each `Charge`: the test's need plus what the
+module- and class-scoped fixtures alive around it keep, projected through the lane's
+fixture state exactly as CPU holds are, since workers report nothing about memory at
+run time. A fixture with recorded memory belongs to its tests' families even when its
+set-up was too quick to matter for time. `_need_memory` is the twin of `_need`; an
+idle worker reserves what its fixtures keep, and a worker whose next test could never
+fit next to what the other workers' fixtures keep is parked like one blocked by CPU
+holds. A fixture reached at run time adds its recorded memory to the queued charges
+when its request is granted.
 
 The budget is `--timing-memory`: a size, or `auto`, which takes 80% of the smallest
 memory the domain's workers report (physical memory capped by the cgroup limit,
 `memory.max` on v2 and `memory.limit_in_bytes` on v1, read like the CPU quota). The
 share is deliberate: estimates are rises above each worker's footprint, and the
-footprints, the controller and the rest of the host are not in them. Without a
-recorded run every estimate is zero and the gate admits everything; the summary says
-so. The planner ignores memory: with tests kept apart by the gate, balancing lanes by
-memory would add little, and the lane plan can still move.
+footprints (session fixtures included), the controller and the rest of the host are
+not in them. Without a recorded run every estimate is zero and the gate admits
+everything; the summary says so. The planner ignores memory: with tests kept apart by
+the gate, balancing lanes by memory would add little, and the lane plan can still move.
+
+Every `Admission` has a `kind` (`cpu` or `memory`), and a refusal records which kinds
+refused (`refused`), as does passing a test over for what other workers keep. When
+the worker is admitted, the wait it records (`AdmissionWait.gates`) says which gates
+held it, and the collector puts it on the test's `cpu.wait` or `memory.wait`
+accordingly. A worker that leaves while parked, having run nothing it waited for,
+has no test to carry its wait: `_release_runtime` records it in `parked`, and each
+gate's summary reports the parked time and worker count beside the tests' waits.
 
 ## Measuring CPU work
 

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.3.1
+
+- Memory admission no longer charges what session- and package-scoped fixtures keep
+  resident. Every worker sets them up once and never lets go, so counting them once
+  per lane, and again against every other lane, could only hold tests back or park
+  a worker until it was shut down: on a suite with a large session fixture the gate
+  left two of eight workers nearly idle and made the run almost three times longer
+  while the host had tens of gigabytes free. Their memory is now the worker's
+  baseline, which the budget's headroom covers (#7).
+- Memory estimates are what a test needs of its own. An attempt that set up shared
+  fixtures was charged its whole rise and, again, what the fixtures kept, twice the
+  residual; its own need is now the rise beyond what stayed. The first attempt on
+  each worker, whose window also covers the worker's warm-up, counts only for a
+  test or fixture with no other attempt (#7).
+- Waits say which gate held the test. A test the memory gate held back carries the
+  seconds in `memory.wait`, beside `cpu.wait` for CPU slots, and the summary line
+  reports memory waits even when a CPU budget is set. Time a worker sat parked and
+  then left without running what it waited for is reported per gate as well, instead
+  of vanishing. The HTML report's table gains a "Held" column and its hover details a
+  "held" line, and the terminal's slowest-tests rows say how long each was held (#7).
+
 ## 0.3.0
 
 - Estimate a test's cost from the median of its best attempts instead of its

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pytest-timing
-Version: 0.3.0
+Version: 0.3.1
 Summary: Record test timings under pytest-xdist and render cargo-style timing reports (ASCII Gantt and HTML).
 Project-URL: Homepage, https://github.com/messense/pytest-timing
 Author-email: messense <messense@icloud.com>
@@ -128,7 +128,10 @@ of the worker's process tree around each test, in bytes: `base` before its set-u
 `peak` during it, and `after` at its teardown. The difference between `peak` and
 `base` is what the test needed on top of the worker's existing footprint; `after`
 minus `base` is what stayed, such as a shared fixture it set up. With
-`--timing-memory`, the run's `memory` describes the budget and how admission went.
+`--timing-memory`, the run's `memory` describes the budget and how admission went,
+and a test the memory gate held back carries the seconds it waited in `memory.wait`,
+as `cpu.wait` does for the CPU gate; the HTML report's table and hover details and
+the terminal's slowest-tests rows show them.
 It also records worker
 lifecycles, detected host CPU environments, and how the session ended (`finished`,
 `collect_only`, `interrupted`, `aborted`, `internal_error`, with pytest's reason). It is
@@ -268,8 +271,8 @@ What to expect:
   forces the oldest blocked request if needed. Such forced reservations can exceed
   the limit and are counted in the summary.
 - The summary reports the budget, the number of tests over one slot, and how long
-  tests waited for slots in total. Each test's JSON record carries its own wait.
-  `cpu.runtime_wait` records admission waits inside a running test. These waits
+  tests waited for slots in total. Each test's JSON record carries its own wait in
+  `cpu.wait`. `cpu.runtime_wait` records admission waits inside a running test. These waits
   are excluded from duration estimates, fixture setup costs and measured CPU rate.
   A runtime request that gets no grant within five minutes cancels the fixture
   setup. It waits to recover the test's original reservation before failing, so
@@ -305,18 +308,26 @@ pytest -n 4 --timing-json --timing-schedule pytest-timing.json --timing-memory 1
 takes 80% of physical memory, capped by the cgroup memory limit. It reads the memory
 each test needed from the run at `--timing-schedule`, so the first run only records;
 the summary says how many tests had recorded memory. A test with no record weighs
-nothing until it has run once. A shared fixture keeps what its first test left resident
-(a loaded model, say) reserved for as long as it is alive, on that worker.
+nothing until it has run once. A module- or class-scoped fixture keeps what its first
+test left resident (a loaded model, say) reserved for as long as it is alive, on that
+worker. What session- and package-scoped fixtures keep is treated as part of every
+worker's footprint instead: each worker sets them up once and never lets go, so
+gating on them could only delay the run, never spare the host.
 
 What to expect:
 
 - The gate is the same fair waiting line as for CPU: a worker whose next test does
   not fit waits with its fixtures alive, and the oldest request goes first. Memory
   and CPU budgets are checked together; a test starts only when both fit.
-- Estimates are the largest rise any recorded attempt showed. They are relative to
+- Estimates are the largest need any recorded attempt showed. For an attempt that
+  set up shared fixtures, what stayed resident afterwards is the fixtures' (or the
+  worker's footprint), and the test's own need is what it used beyond that. The
+  first test on each worker also pays for the worker's warm-up, so its record is
+  used only for a test or fixture with no other attempt. Estimates are relative to
   the worker's footprint, so `auto` leaves a fifth of the host for the workers
-  themselves, the controller and everything else; set a smaller budget on a shared
-  machine.
+  themselves, their session fixtures, the controller and everything else; set a
+  smaller budget on a shared machine, and a larger share of headroom when session
+  fixtures are big.
 - A test recorded above the budget runs alone, and the summary counts it. Allocator
   behaviour can make an estimate low: a test that reuses heap an earlier test freed
   shows a smaller rise than it needs. Large buffers and subprocesses, the usual
@@ -324,6 +335,9 @@ What to expect:
 - Memory does not enter the planner: lanes are still balanced by duration and fixture
   cost, and the gate only delays starts. Under `--dist load` and `worksteal`, like
   CPU admission.
+- The summary says how many tests waited for memory and for how long, and how long
+  workers sat parked at the gate without running what they waited for. Each held
+  test's JSON record carries its wait in `memory.wait`.
 
 ## Re-render or merge saved runs
 

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/README.md

@@ -102,7 +102,10 @@ of the worker's process tree around each test, in bytes: `base` before its set-u
 `peak` during it, and `after` at its teardown. The difference between `peak` and
 `base` is what the test needed on top of the worker's existing footprint; `after`
 minus `base` is what stayed, such as a shared fixture it set up. With
-`--timing-memory`, the run's `memory` describes the budget and how admission went.
+`--timing-memory`, the run's `memory` describes the budget and how admission went,
+and a test the memory gate held back carries the seconds it waited in `memory.wait`,
+as `cpu.wait` does for the CPU gate; the HTML report's table and hover details and
+the terminal's slowest-tests rows show them.
 It also records worker
 lifecycles, detected host CPU environments, and how the session ended (`finished`,
 `collect_only`, `interrupted`, `aborted`, `internal_error`, with pytest's reason). It is
@@ -242,8 +245,8 @@ What to expect:
   forces the oldest blocked request if needed. Such forced reservations can exceed
   the limit and are counted in the summary.
 - The summary reports the budget, the number of tests over one slot, and how long
-  tests waited for slots in total. Each test's JSON record carries its own wait.
-  `cpu.runtime_wait` records admission waits inside a running test. These waits
+  tests waited for slots in total. Each test's JSON record carries its own wait in
+  `cpu.wait`. `cpu.runtime_wait` records admission waits inside a running test. These waits
   are excluded from duration estimates, fixture setup costs and measured CPU rate.
   A runtime request that gets no grant within five minutes cancels the fixture
   setup. It waits to recover the test's original reservation before failing, so
@@ -279,18 +282,26 @@ pytest -n 4 --timing-json --timing-schedule pytest-timing.json --timing-memory 1
 takes 80% of physical memory, capped by the cgroup memory limit. It reads the memory
 each test needed from the run at `--timing-schedule`, so the first run only records;
 the summary says how many tests had recorded memory. A test with no record weighs
-nothing until it has run once. A shared fixture keeps what its first test left resident
-(a loaded model, say) reserved for as long as it is alive, on that worker.
+nothing until it has run once. A module- or class-scoped fixture keeps what its first
+test left resident (a loaded model, say) reserved for as long as it is alive, on that
+worker. What session- and package-scoped fixtures keep is treated as part of every
+worker's footprint instead: each worker sets them up once and never lets go, so
+gating on them could only delay the run, never spare the host.
 
 What to expect:
 
 - The gate is the same fair waiting line as for CPU: a worker whose next test does
   not fit waits with its fixtures alive, and the oldest request goes first. Memory
   and CPU budgets are checked together; a test starts only when both fit.
-- Estimates are the largest rise any recorded attempt showed. They are relative to
+- Estimates are the largest need any recorded attempt showed. For an attempt that
+  set up shared fixtures, what stayed resident afterwards is the fixtures' (or the
+  worker's footprint), and the test's own need is what it used beyond that. The
+  first test on each worker also pays for the worker's warm-up, so its record is
+  used only for a test or fixture with no other attempt. Estimates are relative to
   the worker's footprint, so `auto` leaves a fifth of the host for the workers
-  themselves, the controller and everything else; set a smaller budget on a shared
-  machine.
+  themselves, their session fixtures, the controller and everything else; set a
+  smaller budget on a shared machine, and a larger share of headroom when session
+  fixtures are big.
 - A test recorded above the budget runs alone, and the summary counts it. Allocator
   behaviour can make an estimate low: a test that reuses heap an earlier test freed
   shows a smaller rise than it needs. Large buffers and subprocesses, the usual
@@ -298,6 +309,9 @@ What to expect:
 - Memory does not enter the planner: lanes are still balanced by duration and fixture
   cost, and the gate only delays starts. Under `--dist load` and `worksteal`, like
   CPU admission.
+- The summary says how many tests waited for memory and for how long, and how long
+  workers sat parked at the gate without running what they waited for. Each held
+  test's JSON record carries its wait in `memory.wait`.
 
 ## Re-render or merge saved runs
 

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-timing"
-version = "0.3.0"
+version = "0.3.1"
 description = "Record test timings under pytest-xdist and render cargo-style timing reports (ASCII Gantt and HTML)."
 readme = "README.md"
 license = "MIT"

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/__init__.py

@@ -4,6 +4,6 @@ from __future__ import annotations
 
 from pytest_timing.demand import cpu
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 __all__ = ["__version__", "cpu"]

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/admission.py

@@ -40,8 +40,9 @@ class Admission:
     RECOVER_AFTER = 8
     COOLDOWN = 10.0
 
-    def __init__(self, budget: int, name: str = "local") -> None:
+    def __init__(self, budget: int, name: str = "local", kind: str = "cpu") -> None:
         self.name = name
+        self.kind = kind  # what the slots are: ``cpu`` or ``memory`` (bytes)
         self.budget = max(1, int(budget))
         self.limit = self.budget
         self.reserved: dict[Hashable, Reservation] = {}

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/collector.py

@@ -14,6 +14,7 @@ correct span; they do not change that public occurrence/attempt numbering.
 
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Any
 
@@ -83,12 +84,19 @@ class Collector:
         worker.items = items
 
     def add_wait(
-        self, worker_id: str, nodeid: str, index: int, attempt: int, seconds: float
+        self,
+        worker_id: str,
+        nodeid: str,
+        index: int,
+        attempt: int,
+        seconds: float,
+        gates: Iterable[str] = (),
     ) -> None:
         """Add an admission delay to the exact execution that waited.
 
         A nodeid can have several selections and retries. Looking up its last span
-        at session finish would put every delay on the final one instead.
+        at session finish would put every delay on the final one instead. ``gates``
+        names what held the test (``cpu``, ``memory``); unnamed, the CPU gate did.
         """
         span = self._executions.get((worker_id, index, attempt))
         if span is None:
@@ -98,9 +106,15 @@ class Collector:
             span = self._last.get((worker_id, nodeid))
             if span is None or span.outcome != "crashed" or span.phases or span.attempt != attempt:
                 return
-        if span.cpu is None:
-            span.cpu = CpuRecord(elapsed=span.duration)
-        span.cpu.wait += seconds
+        gates = set(gates)
+        if "cpu" in gates or not gates:
+            if span.cpu is None:
+                span.cpu = CpuRecord(elapsed=span.duration)
+            span.cpu.wait += seconds
+        if "memory" in gates:
+            if span.memory is None:
+                span.memory = MemoryRecord()  # no reading, but the wait is a fact
+            span.memory.wait += seconds
 
     def worker_down(self, worker_id: str, epoch: float, error: str | None) -> None:
         worker = self._worker(worker_id)

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/model.py

@@ -212,14 +212,17 @@ class MemoryRecord:
     ``peak`` the highest reading until the teardown report, ``after`` the reading at
     that report. ``coverage`` says whether descendants were counted (``tree``) or
     only the worker (``self``). A worker's heap rarely shrinks, so ``rise`` is
-    what the attempt needed on top of what was already there, and ``retained`` what
-    stayed resident afterwards: a shared fixture it set up, or a leak.
+    what the attempt needed on top of what was already there, ``retained`` what
+    stayed resident afterwards (a shared fixture it set up, or a leak), and
+    ``transient`` the rest: what it needed beyond what stayed. ``wait`` is how long
+    memory admission held the attempt back before it started, in seconds.
     """
 
     base: int = 0
     peak: int = 0
     after: int = 0
     coverage: str = "none"
+    wait: float = 0.0
 
     @property
     def rise(self) -> int:
@@ -229,13 +232,25 @@ class MemoryRecord:
     def retained(self) -> int:
         return max(0, self.after - self.base)
 
+    @property
+    def transient(self) -> int:
+        return max(0, self.peak - self.after)
+
+    @property
+    def measured(self) -> bool:
+        """Did the platform give a reading? A live process is never resident at zero."""
+        return self.peak > 0
+
     def to_dict(self) -> dict[str, Any]:
-        return {
+        doc: dict[str, Any] = {
             "base": self.base,
             "peak": self.peak,
             "after": self.after,
             "coverage": self.coverage,
         }
+        if self.wait:
+            doc["wait"] = _round(self.wait)
+        return doc
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> MemoryRecord:
@@ -244,6 +259,7 @@ class MemoryRecord:
             peak=int(data.get("peak", 0)),
             after=int(data.get("after", 0)),
             coverage=str(data.get("coverage", "none")),
+            wait=float(data.get("wait", 0.0)),
         )
 
 

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/plugin.py

@@ -176,6 +176,18 @@ def format_bytes(size: float) -> str:
     return f"{size:.1f} TiB"
 
 
+def _waited(summary: dict[str, Any], what: str) -> str:
+    """The waiting part of a gate's summary line: tests held back, workers parked."""
+    text = ""
+    if summary.get("waited_tests"):
+        n = summary["waited_tests"]
+        text += f"; {n} test{'s' if n != 1 else ''} waited {summary['waited']:.2f}s {what}"
+    if summary.get("parked_workers"):
+        n = summary["parked_workers"]
+        text += f"; {n} worker{'s' if n != 1 else ''} sat {summary['parked']:.2f}s parked {what}"
+    return text
+
+
 class Settings:
     """Resolve values by CLI, environment, then ini; enable timing if any source asks."""
 
@@ -573,9 +585,7 @@ class TimingPlugin:
             line += f", largest {format_bytes(summary['largest'])}"
         else:
             line += "; no recorded memory in the schedule history yet"
-        if summary["waited_tests"] and not (scheduler is not None and scheduler.admissions):
-            n = summary["waited_tests"]
-            line += f"; {n} test{'s' if n != 1 else ''} waited {summary['waited']:.2f}s for memory"
+        line += _waited(summary, "for memory")
         return line
 
     def _cpu_summary(self) -> str | None:
@@ -609,9 +619,7 @@ class TimingPlugin:
             return None  # no CPU budget: a memory budget alone has its own line
         line = "cpu: " + "; ".join(parts)
         line += f"; {heavy} test{'s' if heavy != 1 else ''} over one slot"
-        if summary["waited_tests"]:
-            n = summary["waited_tests"]
-            line += f"; {n} test{'s' if n != 1 else ''} waited {summary['waited']:.2f}s for slots"
+        line += _waited(summary, "for slots")
         if summary.get("cancelled"):
             n = summary["cancelled"]
             line += f"; {n} unadmitted test{'s' if n != 1 else ''} withdrawn at shutdown"
@@ -672,6 +680,7 @@ class TimingPlugin:
                     wait.index,
                     wait.attempt,
                     wait.seconds,
+                    wait.gates,
                 )
             self.collector.run.cpu = scheduler.cpu_summary()
             self.collector.run.memory = scheduler.memory_summary()

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/render/ascii.py

@@ -122,8 +122,10 @@ def render_ascii(
                     bar = f"{_RED}{bar}{_RESET}"
                 duration = f"{format_seconds(test.duration):>7}"
                 lines.append(f"{test.worker:<{label_width}} {bar} {duration}")
-                nodeid = _fit_nodeid(test.nodeid, width - label_width - 1, glyphs.ellipsis)
-                lines.append(f"{'':<{label_width}} {nodeid}")
+                held = _held(test)
+                room = width - label_width - 1 - (len(held) + 2 if held else 0)
+                nodeid = _fit_nodeid(test.nodeid, room, glyphs.ellipsis)
+                lines.append(f"{'':<{label_width}} {nodeid}{'  ' + held if held else ''}")
     return "\n".join(lines)
 
 
@@ -265,6 +267,16 @@ def _test_bar(test: TestSpan, scale: Scale, glyphs: Glyphs) -> str:
     return "".join(row)
 
 
+def _held(test: TestSpan) -> str:
+    """How long admission held the test back before it started, and at which gate."""
+    parts = []
+    if test.cpu is not None and test.cpu.wait:
+        parts.append(f"waited {format_seconds(test.cpu.wait)} for cpu")
+    if test.memory is not None and test.memory.wait:
+        parts.append(f"waited {format_seconds(test.memory.wait)} for memory")
+    return ", ".join(parts)
+
+
 def _fit_nodeid(nodeid: str, room: int, ellipsis: str) -> str:
     if room >= len(nodeid) or room < 8 + len(ellipsis):
         return nodeid

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/schedule.py

@@ -13,7 +13,8 @@ from pathlib import Path
 from statistics import fmean, median
 
 from pytest_timing.demand import Declarations, key_base
-from pytest_timing.model import Run
+from pytest_timing.fixtures import key_scope
+from pytest_timing.model import Run, TestSpan
 
 Family = frozenset[str]
 NO_FIXTURES: Family = frozenset()
@@ -23,6 +24,29 @@ EPSILON = 1e-9
 SPLIT_GAIN = 0.01
 """A family is split over more workers only for at least this much predicted gain:
 duplicated set-ups are real cost, and gains this small are within estimate noise."""
+BASELINE_SCOPES = frozenset({"session", "package"})
+"""Scopes whose fixtures' memory is part of the worker's footprint, not a test's need:
+every worker sets them up once and keeps them, so gating on them could only delay
+the run, never spare the host. The budget's headroom is what covers them."""
+
+
+def is_baseline(key: str) -> bool:
+    """Does the fixture behind ``key`` keep memory as a per-worker baseline?"""
+    return key_scope(key) in BASELINE_SCOPES
+
+
+def _warm_ups(run: Run) -> set[int]:
+    """Ids of the first attempt each worker ran.
+
+    Its memory window also covers the worker's warm-up (lazy imports, caches, the
+    allocator's first growth), which is neither the test's need nor a fixture's.
+    """
+    first: dict[str, TestSpan] = {}
+    for test in run.tests:
+        current = first.get(test.worker)
+        if current is None or test.start < current.start:
+            first[test.worker] = test
+    return {id(test) for test in first.values()}
 
 
 @cache
@@ -89,16 +113,21 @@ class Estimates:
         does not grow with the number of attempts the way the longest one does, so a
         history merged from many runs stays comparable to a single run.
 
-        Memory is the opposite: the largest rise any attempt showed, since the worst
-        case is what an out-of-memory kill depends on. What an attempt kept resident
-        after paying for shared set-ups is attributed to those fixtures, split evenly
-        when it paid for several at once, again keeping the largest.
+        Memory is the opposite: the largest need any attempt showed, since the worst
+        case is what an out-of-memory kill depends on. An attempt that paid for shared
+        set-ups needed its whole rise, but what stayed resident afterwards is the
+        fixtures' (split evenly when it paid for several at once) or, for session and
+        package scope, the worker's baseline; the test's own need is the rest
+        (``transient``). The first attempt on each worker also covers the worker's
+        warm-up, so its memory counts only for a test or fixture that has no other
+        attempt.
         """
         attempts: dict[str, dict[int, list[float]]] = {}  # nodeid -> rank -> own seconds
         families: dict[str, set[str]] = {}
         setups: dict[str, list[float]] = {}
-        memory: dict[str, int] = {}
-        retained: dict[str, int] = {}
+        memory: dict[bool, dict[str, int]] = {False: {}, True: {}}  # warm-up? -> bytes
+        retained: dict[bool, dict[str, int]] = {False: {}, True: {}}
+        warm_ups = _warm_ups(run)
         for test in run.tests:
             paid = []
             if test.fixtures:
@@ -107,12 +136,16 @@ class Estimates:
                     if seconds:
                         setups.setdefault(key, []).append(seconds)
                         paid.append(key)
-            if test.memory is not None:
-                memory[test.nodeid] = max(memory.get(test.nodeid, 0), test.memory.rise)
+            if test.memory is not None and test.memory.measured:
+                warm = id(test) in warm_ups
+                rises, keeps = memory[warm], retained[warm]
+                need = test.memory.transient if paid else test.memory.rise
+                rises[test.nodeid] = max(rises.get(test.nodeid, 0), need)
                 if paid and test.memory.retained:
                     share = test.memory.retained // len(paid)
                     for key in paid:
-                        retained[key] = max(retained.get(key, 0), share)
+                        if not is_baseline(key):
+                            keeps[key] = max(keeps.get(key, 0), share)
             if test.outcome == "crashed":
                 continue  # the recorded stop is the worker's death, not the test's
             own = test.duration - test.shared_setup
@@ -132,8 +165,8 @@ class Estimates:
             source,
             {nodeid: frozenset(keys) for nodeid, keys in families.items()},
             {key: median(seconds) for key, seconds in setups.items()},
-            memory,
-            retained,
+            {**memory[True], **memory[False]},  # a clean attempt beats a warm-up one
+            {**retained[True], **retained[False]},
         )
 
     @classmethod
@@ -168,7 +201,10 @@ class Estimates:
         return self.memory.get(nodeid, 0)
 
     def kept(self, key: str) -> int:
-        """Bytes a shared fixture instance keeps resident while alive; unknown is zero."""
+        """Bytes a shared fixture instance keeps resident while alive; unknown is zero,
+        and so is a session or package fixture, whose memory is the worker's baseline."""
+        if is_baseline(key):
+            return 0
         return self.retained.get(key, 0)
 
 
@@ -182,10 +218,11 @@ class Costs:
     tests' families even when no run has timed it yet; one a recorded run reports a
     test using without naming it (``getfixturevalue``) is matched by definition.
 
-    Memory comes from history alone: the bytes each test rose by, and the bytes each
-    shared fixture instance keeps resident. A fixture kept for its memory belongs to
-    its tests' families like a declared one, so the planner keeps it alive on the
-    lane that pays for it and the gate knows it is there.
+    Memory comes from history alone: the bytes each test needs of its own, and the
+    bytes each module- or class-scoped fixture instance keeps resident. A fixture kept
+    for its memory belongs to its tests' families like a declared one, so the planner
+    keeps it alive on the lane that pays for it and the gate knows it is there. What
+    session and package fixtures keep is every worker's baseline and is not charged.
     """
 
     def __init__(

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/static/report.html

@@ -209,7 +209,18 @@ button.on { background: var(--link); color: #fff; border-color: var(--link); }
     t.m = moduleIndex[t.module];
     t.ph = {};
     PHASES.forEach(function (p) { var v = t.phases && t.phases[p]; if (v) t.ph[p] = { start: v[0], stop: v[1], dur: v[2] }; });
+    // Admission waits: how long the controller held the test back before it started, per gate.
+    t.cpuWait = (t.cpu && t.cpu.wait) || 0;
+    t.memWait = (t.memory && t.memory.wait) || 0;
+    t.waited = t.cpuWait + t.memWait;
   });
+  var ANY_WAITED = TESTS.some(function (t) { return t.waited > 0; });
+  function heldText(t) {
+    var parts = [];
+    if (t.cpuWait) parts.push(fmt(t.cpuWait) + ' for cpu');
+    if (t.memWait) parts.push(fmt(t.memWait) + ' for memory');
+    return parts.join(', ');
+  }
   var laneIds = WORKERS.map(function (w) { return w.id; }), laneIndex = {};
   laneIds.forEach(function (id, i) { laneIndex[id] = i; });
   TESTS.forEach(function (t) { if (!(t.worker in laneIndex)) { laneIndex[t.worker] = laneIds.length; laneIds.push(t.worker); } });
@@ -470,6 +481,7 @@ button.on { background: var(--link); color: #fff; border-color: var(--link); }
     ['idx', '#'], ['nodeid', 'Test'], ['worker', 'Worker'], ['dur', 'Total'],
     ['setup', 'Setup'], ['call', 'Call'], ['teardown', 'Teardown'], ['outcome', 'Outcome'], ['start', 'Start']
   ];
+  if (ANY_WAITED) COLS.push(['waited', 'Held']);
   function sortVal(t, key) {
     if (key === 'idx') return t.i;
     if (PHASES.indexOf(key) >= 0) return t.ph[key] ? t.ph[key].dur : 0;
@@ -485,9 +497,10 @@ button.on { background: var(--link); color: #fff; border-color: var(--link); }
       rows.push('<tr><td class="num">' + (n + 1) + '</td><td class="nodeid mono">' + esc(t.nodeid) + (t.attempt ? ' <span class="muted">(attempt ' + (t.attempt + 1) + ')</span>' : '') + '</td><td class="mono">' + esc(t.worker) + '</td>' +
         '<td class="num">' + fmt(t.dur) + '</td>' +
         PHASES.map(function (p) { var ph = t.ph[p]; return '<td class="num">' + (ph ? fmt(ph.dur) + pct(ph.dur, t.dur) : '-') + '</td>'; }).join('') +
-        '<td class="o-' + t.outcome + '">' + esc(t.outcome) + '</td><td class="num">' + fmt(t.start) + '</td></tr>');
+        '<td class="o-' + t.outcome + '">' + esc(t.outcome) + '</td><td class="num">' + fmt(t.start) + '</td>' +
+        (ANY_WAITED ? '<td class="num" title="' + esc(heldText(t)) + '">' + (t.waited ? fmt(t.waited) : '-') + '</td>' : '') + '</tr>');
     });
-    document.querySelector('#tests-table tbody').innerHTML = rows.join('') || '<tr><td colspan="9" class="empty">No tests match the current filters.</td></tr>';
+    document.querySelector('#tests-table tbody').innerHTML = rows.join('') || '<tr><td colspan="' + COLS.length + '" class="empty">No tests match the current filters.</td></tr>';
     document.getElementById('table-note').textContent = tests.length > TABLE_CAP ? '(showing ' + TABLE_CAP + ' of ' + tests.length + ')' : '(' + tests.length + ' of ' + TESTS.length + ')';
   }
 
@@ -528,7 +541,7 @@ button.on { background: var(--link); color: #fff; border-color: var(--link); }
   }
   function tipForTest(t) {
     return '<b>' + esc(t.nodeid) + '</b><br>' + esc(t.outcome) + ' on ' + esc(t.worker) + (t.attempt ? ' (attempt ' + (t.attempt + 1) + ')' : '') +
-      '<br>total ' + fmt(t.dur) + ', started at ' + fmt(t.start) + phaseRows(t);
+      '<br>total ' + fmt(t.dur) + ', started at ' + fmt(t.start) + (t.waited ? '<br>held ' + esc(heldText(t)) : '') + phaseRows(t);
   }
   function tipForCluster(c) {
     var top = c.tests.slice().sort(function (a, b) { return b.dur - a.dur; }).slice(0, 10);

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/src/pytest_timing/xdist_scheduler.py

@@ -74,9 +74,13 @@ class CpuSetup:
 @dataclass(frozen=True)
 class AdmissionWait:
     worker: str
-    index: int
+    index: int  # -1 for a worker that was parked and never ran what it waited for
     attempt: int
     seconds: float
+    gates: frozenset[str] = frozenset()  # the gate kinds that refused: cpu, memory
+
+    def held_by(self, kind: str) -> bool:
+        return kind in self.gates or not self.gates
 
 
 @dataclass(frozen=True)
@@ -127,7 +131,9 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
         self.domain: dict[WorkerController, str] = {}
         self.hosts: dict[str, dict[str, Any]] = {}  # what each domain's workers detected
         self.waiting: dict[WorkerController, float] = {}  # since when its head waits
+        self.refused: dict[WorkerController, set[str]] = {}  # which gate kinds held it
         self.waits: list[AdmissionWait] = []
+        self.parked: list[AdmissionWait] = []  # waits of workers that then ran nothing
         self.rates: dict[str, float] = {}  # last measured CPU rate per worker id
         self.last_sample = -math.inf
         self.cancelled: dict[WorkerController, set[int]] = {}  # withdrawn, never run
@@ -251,7 +257,7 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
         queued = self.node2pending.pop(node)
         lane = self.lanes.pop(node)
         self.dispatched.pop(node, None)
-        self._release_runtime(node)
+        self._release_runtime(node, idle=not queued)
         self.cancelled.pop(node, None)
         self.finished.discard(node)
         self.domain.pop(node, None)
@@ -282,13 +288,20 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
         if node not in self.node2pending:
             return
         self.finished.add(node)
-        self._release_runtime(node)
+        self._release_runtime(node, idle=not self.node2pending[node])
         self._admit_waiting()
 
-    def _release_runtime(self, node: WorkerController) -> None:
+    def _release_runtime(self, node: WorkerController, idle: bool = False) -> None:
+        """Forget ``node``'s run-time state. ``idle`` says it held no test: a wait
+        it was in is then a parked worker's, with no test to record it on."""
         self.requests.pop(node, None)
         self.live_holds.pop(node, None)
-        self.waiting.pop(node, None)
+        since = self.waiting.pop(node, None)
+        gates = frozenset(self.refused.pop(node, ()))
+        if since is not None and idle and self.clock() - since > 0:
+            self.parked.append(
+                AdmissionWait(xdist_compat.node_id(node), -1, 0, self.clock() - since, gates)
+            )
         self.rates.pop(xdist_compat.node_id(node), None)
         for admission in self._gates(node):
             admission.release(node)
@@ -380,19 +393,25 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
                 if not transfer(costs, self._live_lanes(), lane, self._slots()):
                     break
             position = charge = None
+            blocked: set[str] = set()  # the gate kinds that passed tests over
             for i, index in enumerate(lane.plan):
                 charge = costs.charge(index, lane.fixtures)
                 # Could it never run here while the other workers keep what they
                 # hold now? Only their exit would make room: pass it over.
-                if (not elsewhere or min(charge.peak, limit_slots) + elsewhere <= limit_slots) and (
-                    not kept_elsewhere
-                    or min(charge.memory, limit_bytes) + kept_elsewhere <= limit_bytes
+                if elsewhere and min(charge.peak, limit_slots) + elsewhere > limit_slots:
+                    blocked.add("cpu")
+                elif (
+                    kept_elsewhere
+                    and min(charge.memory, limit_bytes) + kept_elsewhere > limit_bytes
                 ):
+                    blocked.add("memory")
+                else:
                     position = i
                     break
             if position is None or charge is None:
                 if not queue and not out:
                     self.waiting.setdefault(node, self.clock())  # parked
+                    self.refused.setdefault(node, set()).update(blocked)
                 break
             if queue and not self._grant(node):
                 break
@@ -458,7 +477,7 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
                 ]
                 size = int(min(offered) * AUTO_MEMORY_SHARE) if offered else 0
             if size > 0:
-                self.memory_admissions[domain] = Admission(size, domain)
+                self.memory_admissions[domain] = Admission(size, domain, kind="memory")
 
     @property
     def gated(self) -> bool:
@@ -602,9 +621,11 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
         assert needs
         lane = self.lanes[node]
         rising = [(gate, need) for gate, need in needs if need > gate.held(node)]
-        if not all(gate.fits(node, need, lane.free) for gate, need in rising):
+        refusing = [gate.kind for gate, need in rising if not gate.fits(node, need, lane.free)]
+        if refusing:
             if wait:
                 since = self.waiting.setdefault(node, self.clock())
+                self.refused.setdefault(node, set()).update(refusing)
                 for gate, need in needs:
                     gate.wait(node, need, since)
             return False
@@ -637,6 +658,7 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
         for gate in self._gates(node):
             gate.admitted(node)
         since = self.waiting.pop(node, None)
+        gates = frozenset(self.refused.pop(node, ()))
         if since is not None:
             queue = self.node2pending[node]
             waited = self.clock() - since
@@ -644,7 +666,9 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
                 request = self.requests.get(node)
                 index = request.index if request is not None else queue[0]
                 attempt = request.attempt if request is not None else 0
-                self.waits.append(AdmissionWait(xdist_compat.node_id(node), index, attempt, waited))
+                self.waits.append(
+                    AdmissionWait(xdist_compat.node_id(node), index, attempt, waited, gates)
+                )
 
     def _reserve(self, node: WorkerController) -> None:
         """Recompute ``node``'s reservation from what it may run without another word."""
@@ -703,6 +727,7 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
             self.cancelled.setdefault(node, set()).add(tail)
             self.withdrawn += 1
             self.waiting.pop(node, None)  # it never ran: no wait to record
+            self.refused.pop(node, None)
             for gate, need in self._needs(node, queue):
                 gate.admitted(node)
                 gate.assign(node, need, lane.free, busy=len(queue) > 1)
@@ -951,11 +976,22 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
             "gated": self.gated,
             "domains": domains,
             "heavy_tests": heavy,
-            "waited": round(sum(w.seconds for w in self.waits), 6),
-            "waited_tests": len({(w.worker, w.index, w.attempt) for w in self.waits}),
+            **self._waits("cpu"),
             "cancelled": self.withdrawn,
         }
 
+    def _waits(self, kind: str) -> dict[str, Any]:
+        """How long tests waited at the gates of ``kind``, and how long workers sat
+        parked at them without ever running what they waited for."""
+        waits = [w for w in self.waits if w.held_by(kind)]
+        parked = [w for w in self.parked if w.held_by(kind)]
+        return {
+            "waited": round(sum(w.seconds for w in waits), 6),
+            "waited_tests": len({(w.worker, w.index, w.attempt) for w in waits}),
+            "parked": round(sum(w.seconds for w in parked), 6),
+            "parked_workers": len({w.worker for w in parked}),
+        }
+
     def memory_summary(self) -> dict[str, Any] | None:
         """What happened on the memory side, for the run's metadata and the summary."""
         if self.cpu is None or self.cpu.memory is None:
@@ -977,8 +1013,7 @@ class DurationScheduling(LoadScheduling):  # type: ignore[misc]  # xdist ships n
             "tests": total,
             "known_tests": known,
             "largest": largest,
-            "waited": round(sum(w.seconds for w in self.waits), 6),
-            "waited_tests": len({(w.worker, w.index, w.attempt) for w in self.waits}),
+            **self._waits("memory"),
         }
 
     def _check_stealing(self, node: WorkerController) -> None:

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/tests/test_ascii.py

@@ -56,6 +56,19 @@ def test_min_duration_filters_slowest(sample_run: Run) -> None:
     assert "test_two" in out and "test_four" not in out
 
 
+def test_slowest_rows_say_how_long_admission_held_a_test(sample_run: Run) -> None:
+    from pytest_timing.model import CpuRecord, MemoryRecord
+
+    two = next(t for t in sample_run.tests if t.nodeid.endswith("test_two"))
+    two.memory = MemoryRecord(base=1, peak=2, after=1, coverage="self", wait=0.3)
+    two.cpu = CpuRecord(elapsed=1.0, wait=1.25)
+    out = render_ascii(sample_run, width=100, top=2)
+    assert "tests/test_a.py::test_two  waited 1.25s for cpu, waited 0.30s for memory" in out
+    for line in out.splitlines():
+        assert len(line) <= 100, line
+    assert "waited" not in render_ascii(sample_run, width=100, top=0)
+
+
 def test_color_only_wraps_glyphs(sample_run: Run) -> None:
     plain = render_ascii(sample_run, width=80)
     colored = render_ascii(sample_run, width=80, color=True)

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/tests/test_collector.py

@@ -27,9 +27,21 @@ def test_waits_use_execution_identity_and_accumulate_across_requests() -> None:
     collector.add_wait("gw0", "test.py::test_same", 9, 0, 0.4)
     collector.add_wait("gw1", "test.py::test_same", 4, 0, 0.6)
     collector.add_wait("gw0", "test.py::test_same", 100, 0, 9)  # never guess another execution
+    collector.add_wait("gw1", "test.py::test_same", 4, 0, 0.7, gates={"memory"})
+    collector.add_wait("gw1", "test.py::test_same", 4, 0, 0.2, gates={"cpu", "memory"})
     run = collector.finish(T0 + 5, termination="finished")
-    assert [t.cpu.wait for t in run.tests if t.cpu] == pytest.approx([0.5, 0.1, 0.4, 0.6])
+    assert [t.cpu.wait for t in run.tests if t.cpu] == pytest.approx([0.5, 0.1, 0.4, 0.8])
     assert [(t.occurrence, t.attempt) for t in run.tests] == [(0, 0), (0, 1), (1, 0), (0, 0)]
+    # A wait at the memory gate goes on the memory record, even without a reading.
+    assert [t.memory.wait for t in run.tests if t.memory] == pytest.approx([0.9])
+    assert run.tests[-1].memory is not None and not run.tests[-1].memory.measured
+    assert run.tests[-1].to_dict()["memory"] == {
+        "base": 0,
+        "peak": 0,
+        "after": 0,
+        "coverage": "none",
+        "wait": 0.9,
+    }
 
 
 def test_phases_fold_into_one_span() -> None:

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/tests/test_html.py

@@ -63,6 +63,21 @@ def test_report_executes_in_a_browser(sample_run: Run, tmp_path: Path) -> None:
     assert "Ended:" in dom and "finished" in dom
 
 
+@needs_chrome
+def test_report_shows_how_long_admission_held_a_test(sample_run: Run, tmp_path: Path) -> None:
+    from pytest_timing.model import CpuRecord, MemoryRecord
+
+    dom = _chrome_dom(sample_run, tmp_path)
+    assert "Held</th>" not in dom  # nothing waited: no column
+    two = next(t for t in sample_run.tests if t.nodeid.endswith("test_two"))
+    two.memory = MemoryRecord(base=1, peak=2, after=1, coverage="self", wait=0.3)
+    two.cpu = CpuRecord(elapsed=1.0, wait=1.25)
+    dom = _chrome_dom(sample_run, tmp_path)
+    assert "Held</th>" in dom
+    assert 'title="1.25s for cpu, 300.0ms for memory">1.55s</td>' in dom
+    assert dom.count('title="">-</td>') == len(sample_run.tests) - 1
+
+
 @needs_chrome
 def test_large_report_executes_in_a_browser(tmp_path: Path) -> None:
     """150k tests on one lane: no argument-limit errors, merged bars, capped table."""

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/tests/test_memory_gate.py

@@ -15,45 +15,100 @@ from pytest_timing.schedule import Costs, Estimates
 
 MIB = 1024 * 1024
 SESSION = "session::/repo/conftest.py::model"
+PACKAGE = "package:tests:/repo/tests/conftest.py::cache"
+MODULE = "module:t.py:/repo/t.py::db"
 
 
-def test_estimates_take_the_largest_rise_and_attribute_retained_memory_to_fixtures() -> None:
+def test_estimates_take_the_largest_need_and_attribute_retained_memory_to_fixtures() -> None:
     c = Collector(make_info())
-    full_test(c, "t.py::a", 0.0)
-    c.tests[-1].memory = MemoryRecord(base=100 * MIB, peak=300 * MIB, after=110 * MIB)
-    full_test(c, "t.py::a", 1.0)  # a second attempt that needed more
-    c.tests[-1].memory = MemoryRecord(base=110 * MIB, peak=360 * MIB, after=110 * MIB)
-    full_test(c, "t.py::b", 2.0)  # paid two set-ups and kept 400 MiB: 200 each
-    c.tests[-1].fixtures = {SESSION: 0.5, "module:t.py:/repo/t.py::db": 0.2}
-    c.tests[-1].memory = MemoryRecord(base=100 * MIB, peak=600 * MIB, after=500 * MIB)
-    full_test(c, "t.py::c", 3.0)  # no record at all
-    run = c.finish(make_info().start + 4, termination="finished")
+    full_test(c, "t.py::warm", 0.0)  # first on gw0: its window covers the warm-up
+    c.tests[-1].memory = MemoryRecord(
+        base=100 * MIB, peak=900 * MIB, after=800 * MIB, coverage="self"
+    )
+    full_test(c, "t.py::a", 1.0)
+    c.tests[-1].memory = MemoryRecord(
+        base=100 * MIB, peak=300 * MIB, after=110 * MIB, coverage="self"
+    )
+    full_test(c, "t.py::a", 2.0)  # a second attempt that needed more
+    c.tests[-1].memory = MemoryRecord(
+        base=110 * MIB, peak=360 * MIB, after=110 * MIB, coverage="self"
+    )
+    full_test(c, "t.py::b", 3.0)  # paid two set-ups and kept 400 MiB: 200 each
+    c.tests[-1].fixtures = {SESSION: 0.5, MODULE: 0.2}
+    c.tests[-1].memory = MemoryRecord(
+        base=100 * MIB, peak=600 * MIB, after=500 * MIB, coverage="self"
+    )
+    full_test(c, "t.py::c", 4.0)  # no record at all
+    full_test(c, "t.py::d", 5.0)  # a wait, but no reading
+    c.tests[-1].memory = MemoryRecord(wait=0.5)
+    run = c.finish(make_info().start + 6, termination="finished")
     est = Estimates.from_run(run)
     assert est.rise("t.py::a") == 250 * MIB
-    assert est.rise("t.py::b") == 500 * MIB
+    # The payer needed its whole rise, but what stayed is the fixtures' (or the
+    # worker's baseline); its own need is what it used beyond that.
+    assert est.rise("t.py::b") == 100 * MIB
     assert est.rise("t.py::c") == 0 and "t.py::c" not in est.memory
-    assert est.kept(SESSION) == 200 * MIB
-    assert est.kept("module:t.py:/repo/t.py::db") == 200 * MIB
+    assert est.rise("t.py::d") == 0 and "t.py::d" not in est.memory
+    assert est.kept(SESSION) == 0 and SESSION not in est.retained  # baseline, not a need
+    assert est.kept(MODULE) == 200 * MIB
     assert est.kept("nothing") == 0
+    # The warm-up window counts only while nothing better is known.
+    assert est.rise("t.py::warm") == 800 * MIB
+    full_test(c, "t.py::warm", 6.0, worker="gw1")  # not the first on its worker
+    c.tests[-1].memory = MemoryRecord(
+        base=100 * MIB, peak=150 * MIB, after=100 * MIB, coverage="self"
+    )
+    full_test(c, "t.py::e", 5.0, worker="gw1")  # gw1's warm-up: earlier, if reported later
+    c.tests[-1].memory = MemoryRecord(
+        base=100 * MIB, peak=700 * MIB, after=600 * MIB, coverage="self"
+    )
+    est = Estimates.from_run(c.finish(make_info().start + 8, termination="finished"))
+    assert est.rise("t.py::warm") == 50 * MIB
+    assert est.rise("t.py::e") == 600 * MIB
+
+
+def test_session_and_package_fixture_memory_is_the_workers_baseline() -> None:
+    c = Collector(make_info())
+    full_test(c, "t.py::a", 0.0)
+    full_test(c, "t.py::b", 1.0)  # paid session, package and module set-ups: 300 each
+    c.tests[-1].fixtures = {SESSION: 0.5, PACKAGE: 0.3, MODULE: 0.2}
+    c.tests[-1].memory = MemoryRecord(
+        base=100 * MIB, peak=1100 * MIB, after=1000 * MIB, coverage="self"
+    )
+    est = Estimates.from_run(c.finish(make_info().start + 2, termination="finished"))
+    assert est.retained == {MODULE: 300 * MIB}
+    assert est.rise("t.py::b") == 100 * MIB
+    # Even hand-written estimates never charge them, and they do not make families.
+    est = Estimates(
+        {"t.py::a": 1.0, "t.py::b": 1.0},
+        families={"t.py::a": frozenset({SESSION, PACKAGE})},
+        setups={SESSION: 0.0, PACKAGE: 0.0},
+        retained={SESSION: 4096 * MIB, PACKAGE: 1024 * MIB},
+    )
+    assert est.kept(SESSION) == 0 and est.kept(PACKAGE) == 0
+    costs = Costs(est, ["t.py::a", "t.py::b"])
+    assert not costs.retained and not costs.any_memory
+    assert costs.family[0] == frozenset()
+    assert costs.charge(0, set()).memory == 0
 
 
-def test_costs_charge_a_test_with_its_rise_and_the_fixtures_alive_around_it() -> None:
+def test_costs_charge_a_test_with_its_need_and_the_fixtures_alive_around_it() -> None:
     ids = ["t.py::a", "t.py::b", "u.py::c"]
     est = Estimates(
         dict.fromkeys(ids, 1.0),
-        families={"t.py::a": frozenset({SESSION}), "t.py::b": frozenset({SESSION})},
-        setups={SESSION: 0.0},  # too quick to matter for time, kept for its memory
+        families={"t.py::a": frozenset({MODULE}), "t.py::b": frozenset({MODULE})},
+        setups={MODULE: 0.0},  # too quick to matter for time, kept for its memory
         memory={"t.py::a": 50 * MIB, "u.py::c": 10 * MIB},
-        retained={SESSION: 300 * MIB},
+        retained={MODULE: 300 * MIB},
     )
     costs = Costs(est, ids, Declarations())
-    assert costs.family[0] == frozenset({SESSION}) and costs.any_memory
-    first = costs.charge(0, set())  # sets the fixture up: rise plus what it will keep
-    assert first.memory == 350 * MIB and SESSION in first.after
-    second = costs.charge(1, first.after)  # no rise of its own, but the fixture is alive
+    assert costs.family[0] == frozenset({MODULE}) and costs.any_memory
+    first = costs.charge(0, set())  # sets the fixture up: its need plus what it will keep
+    assert first.memory == 350 * MIB and MODULE in first.after
+    second = costs.charge(1, first.after)  # no need of its own, but the fixture is alive
     assert second.memory == 300 * MIB
-    third = costs.charge(2, first.after)  # session fixture stays alive across modules
-    assert third.memory == 310 * MIB
+    third = costs.charge(2, first.after)  # a module fixture is gone in another module
+    assert third.memory == 10 * MIB and MODULE not in third.after
     assert costs.kept_memory(first.after) == 300 * MIB
     assert not Costs(Estimates(dict.fromkeys(ids, 1.0)), ids).any_memory
 
@@ -121,6 +176,9 @@ def test_hungry_tests_take_turns_under_a_memory_budget_alone() -> None:
     peak = run_checking_memory(sched, nodes, {i: est.estimate(ids[i]) for i in range(6)})
     assert peak <= 1000 * MIB and peak >= 700 * MIB
     assert sched.waits, "one hungry test had to wait for the other"
+    assert all(w.gates == {"memory"} for w in sched.waits)  # and it was memory that held it
+    assert sched.memory_summary()["waited_tests"] == 1
+    assert sched.cpu_summary()["waited_tests"] == 0 and not sched.parked
     assert sched.now >= 4.0  # the hungry tests ran one after the other
 
 
@@ -148,15 +206,15 @@ def test_a_fixture_that_keeps_memory_counts_against_tests_on_other_workers() ->
     ids = ["f1", "f2", "f3", "big"]
     est = Estimates(
         dict.fromkeys(ids, 1.0),
-        families={f: frozenset({SESSION}) for f in ("f1", "f2", "f3")},
-        setups={SESSION: 0.5},
+        families={f: frozenset({MODULE}) for f in ("f1", "f2", "f3")},
+        setups={MODULE: 0.5},
         memory={"big": 600 * MIB},
-        retained={SESSION: 500 * MIB},
+        retained={MODULE: 500 * MIB},
     )
     sched = memory_scheduler(est, ids, budget=1000 * MIB)
     nodes = start(sched, ids)
     mem = sched.memory_admissions["local"]
-    holder = next(n for n in nodes if SESSION in sched.lanes[n].fixtures)
+    holder = next(n for n in nodes if MODULE in sched.lanes[n].fixtures)
     other = next(n for n in nodes if n is not holder)
     assert mem.held(holder) >= 500 * MIB
     # ``big`` cannot run next to the fixture: it is parked, or waits, until the
@@ -165,6 +223,46 @@ def test_a_fixture_that_keeps_memory_counts_against_tests_on_other_workers() ->
         other in sched.waiting
     )
     run_checking_memory(sched, nodes, dict.fromkeys(range(4), 1.0))
+    assert all(w.gates == {"memory"} for w in sched.waits) and not sched.parked
+
+
+@needs_xdist
+def test_a_parked_worker_that_never_runs_keeps_its_wait_in_the_summary() -> None:
+    ids = ["f1", "f2", "f3", "f4", "big"]
+    est = Estimates(
+        dict.fromkeys(ids, 1.0),
+        families={f: frozenset({MODULE}) for f in ids[:4]},
+        setups={MODULE: 0.5},
+        memory={"big": 600 * MIB},
+        retained={MODULE: 500 * MIB},
+    )
+    sched = memory_scheduler(est, ids, workers=3, budget=1000 * MIB)
+    nodes = start(sched, ids, workers=3)
+    # The fixture family is split over two lanes; ``big`` cannot start next to what
+    # they both keep, so the third worker sits parked with it, undispatched.
+    parked = [n for n in nodes if n in sched.waiting and not sched.node2pending[n]]
+    assert len(parked) == 1 and sched.refused[parked[0]] == {"memory"}
+    assert sched.lanes[parked[0]].plan == [ids.index("big")]
+    sched.now += 3.0
+    sched.remove_node(parked[0])  # gone without a test: nothing to put the wait on
+    assert [(w.index, w.seconds, w.gates) for w in sched.parked] == [
+        (-1, 3.0, frozenset({"memory"}))
+    ]
+    summary = sched.memory_summary()
+    assert summary["parked_workers"] == 1 and summary["parked"] == 3.0
+    assert summary["waited_tests"] == 0
+    assert sched.cpu_summary()["parked_workers"] == 0
+    assert parked[0] not in sched.waiting and parked[0] not in sched.refused
+
+
+def test_summary_lines_say_who_waited_and_who_sat_parked() -> None:
+    from pytest_timing.plugin import _waited
+
+    assert _waited({"waited_tests": 0, "parked_workers": 0}, "for memory") == ""
+    assert (
+        _waited({"waited_tests": 2, "waited": 1.5, "parked_workers": 1, "parked": 3}, "for memory")
+        == "; 2 tests waited 1.50s for memory; 1 worker sat 3.00s parked for memory"
+    )
 
 
 @needs_xdist
@@ -248,7 +346,13 @@ def test_the_second_run_keeps_hungry_tests_apart(pytester: pytest.Pytester, dist
     assert memory["domains"]["local"]["budget"] == 300 * MIB
     assert memory["domains"]["local"]["forced"] == 0
     assert memory["known_tests"] == 5 and memory["largest"] >= 190 * MIB
-    assert memory["waited_tests"] >= 1
+    assert memory["waited_tests"] >= 1 and memory["parked_workers"] == 0
+    # The wait is on the test that was held, marked as memory's, and the chart says so.
+    held = [t for t in doc["tests"] if t.get("memory", {}).get("wait")]
+    assert [t["nodeid"].split("::")[-1] for t in held] in (["test_hungry_a"], ["test_hungry_b"])
+    assert "wait" not in held[0].get("cpu", {})
+    assert sum(t["memory"]["wait"] for t in held) == pytest.approx(memory["waited"], abs=1e-3)
+    second.stdout.fnmatch_lines([f"*{held[0]['nodeid']}  waited * for memory"])
 
 
 @needs_xdist

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/tests/test_runtime_admission.py

@@ -693,11 +693,15 @@ def test_repeated_timeouts_keep_waits_with_the_attempt_that_waited(
 @pytest_timing.cpu(2)
 def heavy(): return 42
 def test_a_competing():
+    # Hold the slot until the other test has asked for the fixture, then long
+    # enough for that request to time out at least once, whatever the host's pace.
     Path("running").touch()
-    time.sleep(.18)
+    wait_for("requested")
+    time.sleep(.15)
 @pytest.mark.flaky(reruns=4)
 def test_b_dynamic(request):
     wait_for("running")
+    Path("requested").touch()
     assert request.getfixturevalue("heavy") == 42
 """
     )

{pytest_timing-0.3.0 → pytest_timing-0.3.1}/uv.lock

@@ -476,7 +476,7 @@ wheels = [
 
 [[package]]
 name = "pytest-timing"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "pytest" },