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

{pytest_timing-0.3.0 → pytest_timing-0.3.2}/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.2}/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.3.2
+
+- The HTML report shows CPU and memory usage. The table gains "CPU time", "CPUs"
+  (the CPUs a test kept busy on average, beside the slots it declared) and "Memory"
+  (what it needed on top of its worker's footprint) columns, the hover details say
+  the same with what the measurement covered, the header totals the run and names
+  each host's budget, and two graphs show CPUs busy and resident memory over time,
+  estimated from the per-test records. All of it appears only where there was a
+  reading.
+
+## 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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pytest-timing
-Version: 0.3.0
+Version: 0.3.2
 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,14 +128,23 @@ 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
 the input to the CLI below and to `--timing-schedule`.
 
 **HTML** is a single file with no external dependencies, so it can be attached to a CI
-job as an artifact and opened anywhere.
+job as an artifact and opened anywhere. Where CPU and memory were measured it shows
+them: each test's CPU time, the CPUs it kept busy on average (beside the slots it
+declared) and the memory it needed on top of its worker's footprint, in the table and
+the hover details; the run's totals and budgets in the header; and CPU and memory
+usage over time. The two graphs are drawn from the per-test records, not sampled: a
+test's CPU time is spread evenly over its run, and a worker counts at its running
+test's peak, so they show where the load was rather than its exact shape.
 
 **Trace** is a Chrome Trace Event file. Open it in
 [Perfetto UI](https://ui.perfetto.dev) with "Open trace file", or in `chrome://tracing`.
@@ -268,8 +277,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 +314,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 +341,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.2}/README.md

@@ -102,14 +102,23 @@ 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
 the input to the CLI below and to `--timing-schedule`.
 
 **HTML** is a single file with no external dependencies, so it can be attached to a CI
-job as an artifact and opened anywhere.
+job as an artifact and opened anywhere. Where CPU and memory were measured it shows
+them: each test's CPU time, the CPUs it kept busy on average (beside the slots it
+declared) and the memory it needed on top of its worker's footprint, in the table and
+the hover details; the run's totals and budgets in the header; and CPU and memory
+usage over time. The two graphs are drawn from the per-test records, not sampled: a
+test's CPU time is spread evenly over its run, and a worker counts at its running
+test's peak, so they show where the load was rather than its exact shape.
 
 **Trace** is a Chrome Trace Event file. Open it in
 [Perfetto UI](https://ui.perfetto.dev) with "Open trace file", or in `chrome://tracing`.
@@ -242,8 +251,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 +288,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 +315,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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-timing"
-version = "0.3.0"
+version = "0.3.2"
 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.2}/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.2"
 
 __all__ = ["__version__", "cpu"]

{pytest_timing-0.3.0 → pytest_timing-0.3.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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__(