spike: record what crashes the compositor, and the copy probe that explains grim-rs

CRASH-FINDING.md is the delegated session's sharper version of the crash result:
hold a live ext capture session on a session's output, kill the session, call
create_frame -> SIGSEGV in CScreenshareFrame::transform(). That is a reproducible
trigger, not a correlation, and it is why ext-image-copy-capture was measured and
then not adopted.

copyout_probe.py prices the per-frame allocate/copy/swizzle that grim-rs's API
forces: 2.2 ms of client time, which is nowhere near its 46 ms deficit against the
in-process route -- so the difference is buffer reuse, not language.
This commit is contained in:
Hermenix committed 2026-10-11 22:47:28 +00:00
1 parent 36efa316fd
commit e2d9cb7dd4
2 files changed
+134

No files matched your search

+57
View File
@@ -0,0 +1,57 @@
# What crashes the compositor, and exactly when
Recorded from the delegated Claude session that spent its run on this, before that
session was shut down. Its finding is sharper than the one the benchmark itself
produced, so it is written down here rather than left in a tmux transcript.
## The trigger
Reproduced deliberately, not just observed:
1. Hold a live capture session on a **session's headless output** (route 001b's
`--protocol ext` producer, i.e. `ext-image-copy-capture-v1`).
2. Run `hhstream session kill` on that session, which destroys its output.
3. Call `create_frame` on the now-dangling capture session.
→ `SIGSEGV`, core dumped.
The kill is **not** the crash: the compositor dies inside
`ext-image-copy-capture`'s frame creation, on an output that no longer exists.
## The stack
```
#0 CScreenshareFrame::transform() const
#1 CImageCopyCaptureFrame::CImageCopyCaptureFrame(...)
#2 CExtImageCopyCaptureManagerV1Options... (createFrame)
#3 _CExtImageCopyCaptureSessionV1CreateFrame
...
#4 ffi_call_unix64
#10 wl_display_run
```
## Why it matters, and what was done about it
- It explains **three** compositor deaths during the benchmark (the two whose
stack reached `CScreenshareFrame::transform()`, and one in `libaquamarine`),
including one that happened mid-run and invalidated cells: the harness kills a
session between passes while a producer may still hold a capture session on it.
So the harness, not the protocol by itself, was pulling the trigger.
- It is the reason the candidate that was measured and **not** adopted is not
adopted: `ext-image-copy-capture-v1` measured no faster than
`zwlr-screencopy-v1` (78.0 vs 77.7 ms; compositor 67.5 vs 67.2 ms) and its
frame-creation path is the one that segfaults the compositor.
The `feat/pywayland-capture` branch therefore keeps the deprecated
`zwlr-screencopy-v1`, with the switch documented as one constant.
- The crash is in Hyprland (0.56.2, software rendering), not in the harness or in
pywayland. Anything that wants to propose it upstream will need this trigger,
because it is the reproducible part: hold a capture session, destroy the
output underneath it, then ask for a frame.
## Not established
- Whether `zwlr-screencopy-v1` survives the same dangling-output sequence. The
in-process backend in `feat/pywayland-capture` does handle the nearest
equivalent (`global_remove` drops the output, and the next `grab()` reconnects
and re-selects) — but that path has not been exercised against a real session
kill, which is the obvious next experiment.
+77
View File
@@ -0,0 +1,77 @@
#!/usr/bin/env python3
"""What does a per-frame copy + swizzle cost? Isolating the grim-rs gap.
The suspicion this answers: a compiled Rust library should not be *slower* than a
subprocess, and pure Python should not be faster than either. The explanation
under test is that the routes are not doing the same work.
grim-rs's public API returns owned pixels -- per capture it does
`mmap.to_vec()` plus an XRGB/ARGB -> RGBA swizzle (its own source, and its own
notes in the results). Our producer hands the mapped buffer straight to the
encoder: no allocation, no copy, no conversion.
So this measures what that extra work costs on this box, on its own, with no
compositor involved: allocate a mapping the size of one 1280x720 frame, then time
(a) copying it out and (b) swizzling it, per frame, over 200 frames.
If the copy+swizzle costs about the gap between our number (~78 ms) and grim-rs's
(~124 ms), then the difference is the work, not the language -- and the honest
conclusion is "a client that reuses its buffer beats one that does not", not
"Python beats Rust".
"""
from __future__ import annotations
import mmap
import os
import statistics
import sys
import time
WIDTH, HEIGHT = 1280, 720
STRIDE = WIDTH * 4
SIZE = STRIDE * HEIGHT
FRAMES = 200
def main() -> int:
memory = mmap.mmap(-1, SIZE)
# Fill with something non-trivial so the copy is not optimised away.
memory.write(b"\x01\x02\x03\x04" * (SIZE // 4))
copies: list[float] = []
swizzles: list[float] = []
both: list[float] = []
for _ in range(FRAMES):
start = time.monotonic_ns()
pixels = bytes(memoryview(memory))
copies.append((time.monotonic_ns() - start) / 1e6)
start = time.monotonic_ns()
swapped = bytearray(len(pixels))
swapped[0::4] = pixels[2::4]
swapped[1::4] = pixels[1::4]
swapped[2::4] = pixels[2::4]
swapped[3::4] = pixels[3::4]
swizzles.append((time.monotonic_ns() - start) / 1e6)
both.append(copies[-1] + swizzles[-1])
del pixels, swapped
print(f"frame: {WIDTH}x{HEIGHT}, {SIZE / 1e6:.2f} MB, {FRAMES} frames")
for label, samples in (("copy only (mmap -> Vec)", copies),
("swizzle only (BGRX -> RGBA)", swizzles),
("copy + swizzle", both)):
print(f" {label:<28} p50 {statistics.median(samples):>6.2f} ms "
f"min {min(samples):>6.2f} max {max(samples):>6.2f}")
print("\nAdd 'copy + swizzle' to the in-process route's number to compare it "
"against a library that returns owned pixels.")
memory.close()
# Flush before `os._exit`: os._exit skips the interpreter's cleanup, so
# buffered stdout is dropped -- the first run of this printed nothing at all.
sys.stdout.flush()
os._exit(0)
if __name__ == "__main__":
raise SystemExit(main())