Add memory allocation attribution tests for single- and multithreaded contexts (#1049)

Covers four regression surfaces not asserted on before: two-allocator byte
proportionality, Python-vs-C allocator split, pure-Python multithreaded
per-thread attribution, and issue #857 (GIL-releasing worker allocations
smearing onto main-thread idle frames).

New fixtures in test/line_attribution_tests/ (single-threaded and
multithreaded), six test files in tests/, and a shared subprocess helper
factored out of the existing _run_scalene duplication. Windows skips on
tests that read memory_stacks (whereInPythonWithStack not implemented in
libscalene_windows.cpp); byte-attribution tests run on Windows.

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: emeryberger

test/line_attribution_tests/mt_gil_release_worker.py

@@ -0,0 +1,39 @@
+"""Multithreaded fixture: worker allocates under a released GIL (numpy).
+
+Used by ``tests/test_memory_multithreaded_gil_release.py``. This is the
+asserting form of ``test/test-native-thread-alloc.py`` and pins issue
+#857: when OpenBLAS/MKL drop the GIL inside a numpy allocation, the
+sampled bytes must still be attributed to the worker thread's Python
+frame, not to ``time.sleep`` on the main thread where the GIL happens
+to be held.
+
+Line numbers are load-bearing: WORKER_ALLOC_LINE, MAIN_SLEEP_LINE are
+referenced as integer constants. If numpy is unavailable, exit cleanly
+so the test skips.
+"""
+import sys
+import threading
+import time
+
+try:
+    import numpy as np
+except ImportError:
+    sys.exit(0)
+
+
+def worker():
+    for _ in range(40):
+        a = np.zeros((1024, 1024), dtype=np.float64)  # line 26 — ~8 MB via libc malloc, GIL often released (WORKER_ALLOC_LINE)
+        a += 1.0
+        del a
+
+
+def main():
+    t = threading.Thread(target=worker)
+    t.start()
+    time.sleep(2.0)  # line 34 — main-thread idle; must NOT be charged with worker bytes (MAIN_SLEEP_LINE)
+    t.join()
+
+
+if __name__ == "__main__":
+    main()

test/line_attribution_tests/mt_two_workers.py

@@ -0,0 +1,58 @@
+"""Multithreaded fixture: two worker threads, each with its own allocator line.
+
+Used by ``tests/test_memory_multithreaded.py`` and
+``tests/test_memory_multithreaded_stacks.py``. Both workers allocate pure
+Python ``array.array`` objects under the GIL — no numpy, no GIL release
+— so any attribution gap across threads reflects the stack-walk path in
+``whereInPythonWithStack``, not a GIL-release confounder.
+
+Per-worker allocator lines get compared directly against each other
+(same iteration count; allocation sizes differ by 4x). The main thread's
+``sleep`` and ``join`` lines must NOT be charged with worker bytes — that
+would mean Scalene is walking the wrong thread's Python stack when a
+sample fires inside a worker.
+
+Line numbers are load-bearing: WORKER_A_ALLOC_LINE, WORKER_B_ALLOC_LINE,
+MAIN_SLEEP_LINE, MAIN_JOIN_LINE are referenced as integer constants.
+"""
+import array
+import threading
+import time
+
+
+def spin_a_bit():
+    deadline = time.time() + 0.05
+    acc = 0
+    while time.time() < deadline:
+        acc += 1
+    return acc
+
+
+def worker_a():
+    held = []
+    for _ in range(50):
+        held.append(array.array("d", [0]) * 200_000)  # line 34 — ~1.6 MB (WORKER_A_ALLOC_LINE)
+        spin_a_bit()
+    return len(held)
+
+
+def worker_b():
+    held = []
+    for _ in range(50):
+        held.append(array.array("d", [0]) * 800_000)  # line 42 — ~6.4 MB (WORKER_B_ALLOC_LINE)
+        spin_a_bit()
+    return len(held)
+
+
+def main():
+    t_a = threading.Thread(target=worker_a)
+    t_b = threading.Thread(target=worker_b)
+    t_a.start()
+    t_b.start()
+    time.sleep(2.5)  # line 52 — main-thread idle (MAIN_SLEEP_LINE)
+    t_a.join()       # line 53 — main-thread idle (MAIN_JOIN_LINE)
+    t_b.join()
+
+
+if __name__ == "__main__":
+    main()

test/line_attribution_tests/st_python_vs_c.py

@@ -0,0 +1,51 @@
+"""Single-threaded fixture: Python-allocator vs C-allocator byte split.
+
+Used by ``tests/test_memory_python_vs_c.py``. The CPython bytes allocator
+counts toward the interposer's ``_pythonCount`` (see
+``src/include/sampleheap.hpp``); numpy's ``np.zeros`` goes through libc
+``malloc`` and counts toward ``_cCount``. The Python-fraction field in
+the JSON output (``n_python_fraction``) should reflect this split
+per-line.
+
+Line numbers are load-bearing: PYTHON_LINE and C_LINE are asserted on
+directly. If numpy is unavailable, exit cleanly so the test skips
+instead of failing spuriously.
+"""
+import sys
+import time
+
+try:
+    import numpy as np
+except ImportError:
+    # Fixture degrades cleanly: no samples attributed to this file,
+    # the test recognizes the missing fixture and skips.
+    sys.exit(0)
+
+
+def spin_a_bit():
+    deadline = time.time() + 0.05
+    acc = 0
+    while time.time() < deadline:
+        acc += 1
+    return acc
+
+
+def python_alloc():
+    return bytes(2 * 10_485_767)  # line 34 — ~20 MB via CPython allocator (PYTHON_LINE)
+
+
+def c_alloc():
+    return np.zeros(2_000_000, dtype=np.float64)  # line 38 — ~16 MB via libc malloc (C_LINE)
+
+
+def run():
+    held = []
+    for _ in range(30):
+        held.append(python_alloc())
+        held.append(c_alloc())
+        spin_a_bit()
+    return len(held)
+
+
+if __name__ == "__main__":
+    print(run())

test/line_attribution_tests/st_two_allocators.py

@@ -0,0 +1,45 @@
+"""Single-threaded fixture: two allocator functions with different byte sizes.
+
+Used by ``tests/test_memory_two_allocators.py`` and
+``tests/test_memory_stack_leaf_singlethread.py``. Both allocator functions
+run the same number of times, so per-line byte attribution should be
+proportional to each allocator's per-call size (~4x spread here, tests
+only assert a loose 2x to absorb sampling noise).
+
+Line numbers are load-bearing: the tests reference SMALL_LINE and BIG_LINE
+by integer constants. Do not reformat without updating those constants.
+"""
+import array
+import time
+
+
+def spin_a_bit():
+    # Burn CPU so Scalene takes multiple sampling intervals before the
+    # program exits. Without this, the loop can complete before a single
+    # SIGVTALRM fires, and Scalene emits an empty profile.
+    deadline = time.time() + 0.05
+    acc = 0
+    while time.time() < deadline:
+        acc += 1
+    return acc
+
+
+def small_alloc():
+    return array.array("d", [0]) * 150_000  # line 28 — ~1.2 MB (SMALL_LINE)
+
+
+def big_alloc():
+    return array.array("d", [0]) * 600_000  # line 32 — ~4.8 MB (BIG_LINE)
+
+
+def run():
+    held = []
+    for _ in range(40):
+        held.append(small_alloc())
+        held.append(big_alloc())
+        spin_a_bit()
+    return len(held)
+
+
+if __name__ == "__main__":
+    print(run())

tests/_scalene_subprocess.py

@@ -0,0 +1,114 @@
+"""Shared helper for end-to-end memory-attribution tests.
+
+Runs Scalene as a subprocess against a fixture, retries on empty output,
+and skips cleanly if no usable profile ever comes back. Factored out of
+``tests/test_line_attribution_nested.py`` and ``tests/test_memory_stacks_bigmem.py``
+once a third family of tests started needing the same logic.
+
+Not a test module — pytest ignores files whose basename starts with ``_``.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import pytest
+
+
+def run_scalene_memory_profile(
+    tmp_path: Path,
+    fixture: Path,
+    *,
+    extra_args: Optional[List[str]] = None,
+    timeout: int = 120,
+    attempts: int = 3,
+    require_memory_stacks: bool = False,
+) -> dict:
+    """Profile *fixture* with ``--memory``; return the parsed JSON profile.
+
+    Retries on two known flake modes:
+      - Scalene startup wedges (``DYLD_INSERT_LIBRARIES`` / ``sys.monitoring``
+        init under CI contention): caught via ``TimeoutExpired``.
+      - Scalene runs but writes no samples for the fixture (program finished
+        before a sampling interval): detected by the fixture path not being
+        present in ``profile["files"]``.
+
+    If ``require_memory_stacks`` is set, an otherwise-valid profile whose
+    ``memory_stacks`` is empty is also treated as a failed attempt. Used by
+    tests that assert on the synchronous stack-capture output.
+    """
+    extra = list(extra_args or [])
+    fixture_name = fixture.name
+    last: Optional[subprocess.CompletedProcess] = None
+    for attempt in range(1, attempts + 1):
+        out = tmp_path / f"{fixture.stem}_{attempt}.json"
+        cmd = [
+            sys.executable,
+            "-m",
+            "scalene",
+            "run",
+            "--memory",
+            "--no-browser",
+            "-o",
+            str(out),
+            *extra,
+            str(fixture),
+        ]
+        try:
+            last = subprocess.run(
+                cmd,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired:
+            continue
+        if not (out.exists() and out.stat().st_size > 0):
+            continue
+        with open(out) as f:
+            profile = json.load(f)
+        files = profile.get("files", {})
+        if not any(fname.endswith(fixture_name) for fname in files):
+            continue
+        if require_memory_stacks and not profile.get("memory_stacks"):
+            continue
+        return profile
+    pytest.skip(
+        f"Scalene produced no usable profile for {fixture_name} after "
+        f"{attempts} attempts (suspected subprocess startup flake). "
+        f"last returncode={last.returncode if last else 'timeout'}, "
+        f"last stderr={(last.stderr[-400:] if last else '')!r}"
+    )
+
+
+def fixture_lines(profile: dict, fixture_basename: str) -> List[dict]:
+    """Return the per-line records for the file whose path ends in *fixture_basename*.
+
+    ``run_scalene_memory_profile`` only returns profiles where the fixture is
+    present, so the guard here is for misuse (wrong basename) rather than
+    flake.
+    """
+    files = profile.get("files", {})
+    matches = [
+        fdata for fname, fdata in files.items() if fname.endswith(fixture_basename)
+    ]
+    assert matches, (
+        f"Fixture {fixture_basename!r} missing from profile: "
+        f"files={list(files.keys())}"
+    )
+    return matches[0]["lines"]
+
+
+def leaf_line(frames: List[dict]) -> Optional[int]:
+    """Line number of the innermost (leaf) frame in a ``memory_stacks`` entry."""
+    return frames[-1]["line"] if frames else None
+
+
+def leaf_filename(frames: List[dict]) -> Optional[str]:
+    """Filename of the innermost frame."""
+    return frames[-1].get("filename_or_module") if frames else None