diff --git a/docs/ClusterFinderCUDA_benchmark_results.md b/docs/ClusterFinderCUDA_benchmark_results.md index 0adf7073..319a844b 100644 --- a/docs/ClusterFinderCUDA_benchmark_results.md +++ b/docs/ClusterFinderCUDA_benchmark_results.md @@ -1367,7 +1367,7 @@ opt1/opt2 stop over-counting extended charge-shared events: | exploratory notebook | `python/tests/ClusterFinderCUDA_perf.ipynb` | **stores only the last run** — not a record. Archive a copy per cluster size if used | | correctness notebook | `python/tests/ClusterFinderFrozen_vs_CUDA.ipynb` | CPU↔CUDA agreement analysis | | precision study | `docs/pedestal_precision_f32_cancellation.md` | B1 derivation | -| deck | `docs/cf_cuda_performance.pptx` + `docs/deck/build_performance_deck.py` | 35 slides in the same three acts plus a 6-group annex (A1–A6), 53 pages with dividers; figures from `docs/deck/make_figs.py` and `make_figs_kernel.py`. Rebuild with `python docs/deck/make_figs.py && python docs/deck/build_performance_deck.py` | +| deck | `docs/cf_cuda_performance.pptx` + `docs/deck/build_performance_deck.py` | 35 slides in the same three acts plus a 7-group annex (A1–A7, A7 in two parts), 55 pages with dividers; figures from `docs/deck/make_figs.py` and `make_figs_kernel.py`. Rebuild with `python docs/deck/make_figs.py && python docs/deck/build_performance_deck.py` | ### CSV step labels diff --git a/docs/cf_cuda_performance.pptx b/docs/cf_cuda_performance.pptx index 8dd13794..eb81e7ce 100644 Binary files a/docs/cf_cuda_performance.pptx and b/docs/cf_cuda_performance.pptx differ diff --git a/docs/deck/CHANGELOG_2026-08-25.md b/docs/deck/CHANGELOG_2026-08-25.md index d37088d1..e318cc87 100644 --- a/docs/deck/CHANGELOG_2026-08-25.md +++ b/docs/deck/CHANGELOG_2026-08-25.md @@ -454,3 +454,120 @@ printing one under the other's name. - `build_internals_deck.py` and `cf_cuda_internals.pptx` deleted: the four engineering slides they held are now folded into the single deck, in the arc, which is what "one deck with a bit more detail" means. + +--- + +## §13 — Which test causes the CPU-vs-CPU residual (annex A7, new) + +Slide 30 said the serial-vs-frozen gap was "update timing alone" and stopped +there. Which of the three decisions the timing actually moves had never been +measured. It has been now, two independent ways. + +**Instrumented** (both finders running shipped logic; each records a per-pixel +branch code, and the two maps are diffed frame by frame). 974 pixels out of +1.6 × 10⁹ take a different branch, and the ones that change the cluster set +decompose onto the 8/11 headline with no remainder: + +| | | | +|---|--:|---| +| frozen-only 11 | `QUIET_UPDATE → TEST3_STORE` (11) | **all Test 3** | +| cpu-only 8 | `TEST3_STORE → TEST3_SKIP` (5) + `TEST1_STORE → SHADOW` (3) | **all local-max gate** | +| Test 1 threshold | 619 flips | **zero clusters** | + +**Ablated** (Test 3 compiled out of both finders): + +| | Test3 ON | Test3 OFF | +|---|--:|--:| +| clusters (cpu) | 23 244 602 | 23 241 342 | +| divergent pixels | 974 | 584 | +| first divergent frame | 4 | 30 | +| frozen-only | **11** | **0** | +| cpu-only | 8 | 4 | + +The 11 go to zero exactly. The surviving cpu-only 4 are all local-max-gate +flips, which do not need Test 3; the count is not preserved because ablating +changes which pixels push, so the pedestal takes a different path and the +downstream ties are a different realisation. + +**Two claims made along the way turned out to be wrong and are corrected in the +notes.** First, that the residual on slide 31 was the timing effect — it is not, +it is the f32 EMA row (`0 / 6`), and both finders freeze the pedestal there. +Second, that Test 1 flips are merely downstream of Test 3 — with Test 3 ablated +the first divergence is still a Test 1 flip, on a frame where the pedestals were +provably identical. Test 1 initiates independently, roughly 7× slower, and can +never create a cluster by itself. + +**A7 is two slides, because part 2 blames a test slide 4 does not show.** Slide +4's panel is titled "THE WHOLE ALGORITHM" and has two tests; the finder has +three. Part 1 restores the third branch and explains `c3 = √(3×3) = 3` as the +noise scaling of a 9-pixel sum — so Test 3 is the same 5σ criterion as Test 1 +applied to the window rather than the pixel. Part 2 carries the measurement. + +`fig_test3` is the site at frame 203, pixel (125,245): a 21×21 context view with +the raster caught mid-frame on the left, and the 3×3 the decision was taken on +at right, each differing cell showing both finders' readings. Threshold +256.511; serial sums 256.489 and frozen 256.581. **`max` is 56.473 in both**, +which is the argument in one number. + +**Instrumentation is gated.** `AARE_BRANCH_TRACE` defaults to 0 and the writes +fold away at compile time, so the CPU baseline whose throughput the deck quotes +is unaffected. `AARE_TEST3_ENABLED` defaults to 1. Both live in the two CPU +headers; `python/tests/branch_trace.py` and `branch_site_dump.py` document the +rebuild. + +--- + +## §14 — Two layout fixes and one figure that contradicted itself + +**Slide 18's row tag was 0.1 in under the strip above it.** `fig_overlap_9x9` +placed each row's tag at `yG + lane_h + 7` but spaced rows only 33 units apart, +so "3 slots · the natural next guess" collided with the 2-slot host lane. Row +spacing has to clear the row's *tallest* element, which is the tag rather than +the lane: `lane_h 9→8`, spacing `33→37`, tag offset `+7→+4.5`, and the reason is +now a comment so the next edit does not undo it. + +**`c3` now derives itself.** The A7 · 1/2 callout led with the conclusion; it now +leads with variance addition and carries the formula — `Var(Σ v) = 9σ²`, hence +`√9 · σ = 3σ`. The notes add what the slide has no room for: standard deviations +do not add but variances do (the entire content of the √); summing buys a factor +3 in SNR because signal adds linearly ×9 while noise adds in quadrature ×3; and +the independence caveat, since correlated noise would need covariance terms and +push `c3` above `√N`. + +**`fig_test3`'s left panel claimed two incompatible things.** It painted a +completed branch map — read after `find_clusters()` returns, 441 cells, zero +undecided — and then drew a "the scan is here" cursor over it, with amber +decided pixels below and to the right of the arrow. Caught in review from the +picture alone. The panel is now explicitly the finished frame, the arrows moved +outside the grid and became raster **order** rather than progress, and the two +panels each name their clock: left "the finished frame", right "the moment +(125,245) was tested". + +**The same figure merged two fills into one legend line** — "photon: stored, or +in its shadow" covered both green and slate, which invited the reasonable +question *why is that photon 3×4 pixels?* It isn't: there are exactly 9 green +cells in the patch and every one is a single pixel. Shadow now has its own row, +stated as the rule rather than the appearance: + +> shadow is every pixel whose **own** 3×3 window contains something above 5σ + +with the three tiers in the notes — 810.3 ADU stored, 345.0 shadowed because it +is not the peak, 17.7 shadowed although nowhere near the 85.5 bar, because its +window reaches the 345. Charge shared across two adjacent pixels lights up the +union of every window that can see either, which is how a region gets to 3×4. + +**The marked pixel stays amber with a green ring.** The panel is coloured by the +serial finder and serial *sampled the pedestal* there; only frozen stored. +Painting it plain green would have read better and contradicted the Σ lines +beside it. + +**Stale artefacts removed.** `fig_bottleneck`, `fig_correctness` and +`fig_variance_rewrite` were listed as *still open* above — generated on every run +but placed on no slide. Their call sites are now commented out (the functions +stay: they are the only record of how those figures were built) and the three +PNGs are deleted, so the next run cannot resurrect them. `docs/figures` now holds +exactly the 31 figures the deck places, plus the four `Eta*` images that belong +to the Sphinx docs. Also dropped `docs/deck/branch_trace.json`, a byte-identical +copy of the `python/tests/` original that nothing read — `branch_site.json` is +duplicated on purpose, because `make_figs.py` needs the deck build to be +self-contained. diff --git a/docs/deck/QA.md b/docs/deck/QA.md new file mode 100644 index 00000000..6f5b5d53 --- /dev/null +++ b/docs/deck/QA.md @@ -0,0 +1,679 @@ +# Questions the room will ask + +Answers worked out while building `docs/cf_cuda_performance.pptx`, kept because most +of them came from someone reading a slide and not believing it. Each one names the +slide it belongs to and the code or measurement that settles it. + +Conventions used throughout: **s1** is one stream (true exclusive engine durations), +**s4** is the shipped four-stream pipeline (engine *occupancy*), and **floor** is +`1 / max(H2D, kernel, D2H)` at s4 — 30.01 µs/frame = 33 323 FPS at 9×9. Numbers come +from `docs/ClusterFinderCUDA_benchmark_results.md`; section references are to it. + +--- + +## 1 · The result path — D2H, pinned buffers, chunks and slots + +### Q. Where do 93 kB/frame (3×3) and 467 kB/frame (9×9) come from? + +They are `clusters actually found × sizeof(ClusterType)`, per frame, averaged over the +run. Neither is a measured byte count from a profiler; both are arithmetic on the +cluster struct. + +`Cluster` is two `CoordType` coordinates plus `std::array`. With 16-bit coords +and `int32` data that is `4 + 9×4 = 40 B` at 3×3 and `4 + 81×4 = 328 B` at 9×9 — +`alignof` 4, no tail padding, so `sizeof` is exact. + +| | cap | fill | clusters/frame | × sizeof | payload | +|---|--:|--:|--:|--:|--:| +| 3×3 | 3000 | 77 % | ~2310 | × 40 B | **~93 kB** | +| 9×9 | 1700 | 84 % | ~1428 | × 328 B | **~467 kB** | + +The fills are the campaign occupancies printed in §8 — 77 % at cap 3000, 84 % at +cap 1700. + +### Q. So is 93 kB the size of the D2H transfer? + +**No, and this is the distinction worth making out loud.** There are two different +byte counts on this path and they are not close. + +- **The D2H is occupancy-blind.** The device writes into a fixed envelope and the + copy moves the whole envelope regardless of how many clusters were found: + + ```cpp + m_clusters_offset = align_up(sizeof(uint32_t), alignof(ClusterType)); // = 4 + m_output_bytes_per_frame = m_clusters_offset + + m_max_clusters_per_frame * sizeof(ClusterType); + ``` + (`ClusterFinderCUDA.hpp:442-445`) + + That is **120 004 B/frame at cap 3000** and **557 604 B/frame at cap 1700** — the + 4-byte count, aligned, then `cap` cluster slots whether or not they are used. + +- **The host memcpy is occupancy-aware.** `materialize_slot()` reads the count and + copies only that many: + + ```cpp + uint32_t n_found = *reinterpret_cast(h_out); + n_found = std::min(n_found, m_max_clusters_per_frame); + if (n_found > 0) + std::memcpy(results[frame_idx].data(), src, n_found * sizeof(ClusterType)); + ``` + (`ClusterFinderCUDA.hpp:138-158`) + + That is the 93 kB / 467 kB. + +So: **93 kB is what the CPU copies, ~120 kB is what the PCIe link moves.** The deck's +payload table splits them for exactly this reason. Quoting 93 kB as "the D2H" would +understate it by ~23 % at 3×3 and ~16 % at 9×9. + +The clamp on `n_found` is a bounds guard, not a tuning knob: the device counter is +incremented unconditionally and only the *write* is guarded, so the counter can read +past the cap on an overflowing frame. + +### Q. Why is the cap 3000 at 3×3 but only 1700 at 9×9? + +Both are lossless caps for their geometry — the smallest value at which no frame in +the campaign overflows. They differ because the cluster is 8.2× larger at 9×9, so the +same envelope buys far fewer slots, and because D2H cost scales with `cap × sizeof`: +raising 9×9 from 1500 to the lossless 1700 already moved D2H from 22.8 to 25.2 µs, +which on the `[f32]` arm overtakes the 23.9 µs kernel. Doubling to 3000 would put D2H +near 45 µs/frame and make the copy the binding engine (§8, §11.4). + +### Q. Is the pinned buffer one frame, or one batch? + +One **chunk**, and there are two of them. + +```cpp +static constexpr int NUM_SLOTS = 2; +void grow_output_slot(int slot, size_t n_frames) { + if (n_frames <= m_output_slot_capacity[slot]) return; // only ever grows + if (h_output_slots[slot]) CUDA_CHECK(cudaFreeHost(h_output_slots[slot])); + CUDA_CHECK(cudaMallocHost(&h_output_slots[slot], + n_frames * m_output_bytes_per_frame)); + m_output_slot_capacity[slot] = n_frames; +} +``` +(`ClusterFinderCUDA.hpp:1126-1137`) + +So the pinned footprint is `NUM_SLOTS × chunk × m_output_bytes_per_frame`. At 3×3 with +a 2000-frame chunk that is `2 × 2000 × 120 004 B ≈ 480 MB`. The "only ever grows" +property matters: a run whose batches keep the same shape allocates **once**, and every +subsequent chunk reuses already-faulted pages. + +### Q. What is a chunk, exactly, and what sets its size? + +A chunk is the number of frames whose results fit in one slot — the pipelining unit. +`resolve_batch_chunk()` (`ClusterFinderCUDA.hpp:185-211`) picks it: + +1. Aim for `DEFAULT_BATCH_CHUNKS = 8` chunks over the call. +2. Floor at `n_streams × 4` frames, or the per-chunk drain dominates. +3. **Cap by bytes, not frames**: `MAX_SLOT_BYTES = 128 MiB`. +4. Round up to a multiple of `n_streams`. + +Step 3 is the one that surprises people. `128 MiB / 120 004 B` = **1120 frames at 3×3**; +`128 MiB / 557 604 B` = **240 frames at 9×9**. Without it, +`find_clusters_batched(whole_array)` scales the pinned allocation with the array — +20 000 frames at 9×9 gives 2500-frame chunks = 1.23 GB per slot, 2.46 GB pinned, whose +first-touch cost (~600 k page faults) lands inside the caller's timed region. + +Step 4 is a **correctness** requirement, not tidiness: the device pedestal is +per-stream, so changing which stream a frame lands on would change the pedestal state +that frame is evaluated against. + +`set_batch_chunk(n)` bypasses the whole thing, byte cap included. + +### Q. What happens when a slot is full? Where do the results of frame 2241 go? + +With chunk `C` and 2 slots, chunk 0 goes to slot 0, chunk 1 to slot 1, chunk 2 back to +slot 0. `m_next_slot = 1 - slot` (`:688`) is the whole rotation. + +There is **no blocking wait** at the submit end — `submit_batch` *throws* if the slot it +is about to reuse is still in flight: + +```cpp +if (m_slot_in_flight[slot]) + throw std::runtime_error("ClusterFinderCUDA: both batch slots are in flight " + "— call collect() before submitting a third batch"); +``` +(`ClusterFinderCUDA.hpp:676-680`) + +The back-pressure lives in the **caller's loop order** instead. `find_clusters_batched` +submits chunk *b+1* and only then collects chunk *b*, so a slot is always free by the +time it comes round again: + +```cpp +BatchToken nxt = submit_batch(frames.sub_view(b, e), first_frame + b); +drain(collect(tok)); // GPU runs chunk b while the host drains b-1 +tok = nxt; +``` +(`ClusterFinderCUDA.hpp:878-889`) + +The waiting therefore happens inside `collect` → `finish_slot`, on +`cudaEventSynchronize`. That is what makes the steady-state period `max(GPU, host)`. + +With a 2000-frame chunk, frame 2241 is in chunk 1 → slot 1, at byte offset +`241 × m_output_bytes_per_frame` into that slot's pinned block. + +### Q. Does zero-copy (opt6) eliminate the D2H? + +**No.** It eliminates the *host-side* copy — the `std::memcpy` in `materialize_slot()` +that moves data from the pinned buffer into freshly-`malloc`'d pageable memory, plus +the per-frame allocation that feeds it. The device→host transfer over PCIe is +untouched; the results still have to cross the bus. + +```cpp +/// Nothing is copied and nothing is allocated: the returned view points into +/// the finder's pinned D2H buffer. The slot is held until the view is +/// released, so at most NUM_SLOTS - 1 further batches can be submitted while +/// it is alive. Consume, then release. +BatchView collect_view(BatchToken token); +``` +(`ClusterFinderCUDA.hpp:815-833`) + +The cost of the deal is the sentence at the end: holding a view holds a slot, so the +pipeline depth drops to 1 while you are reading. Consume promptly. + +### Q. Do minor page faults still happen on the pinned buffer? + +Yes, but they are paid **once per allocation**, not once per frame. `cudaMallocHost` +page-locks the region and its first touch is charged to whoever triggers it; because +`grow_output_slot` only ever grows, a steady-shape run touches those pages on the first +chunk and never again. + +The faults that *scale with frame count* are on the other side — the per-frame `malloc` +inside `materialize_slot()`, which hands back fresh pages every frame. That is the +distinction that makes opt6 worth ×2.21 at 9×9: it deletes the faulting allocation, not +the transfer. + +### Q. Where exactly is the host allocation, and where is its time paid? + +Two allocations on this path, on completely different schedules. Conflating them is the +easiest way to misread the opt5/opt6 numbers. + +**Pinned, once per shape** — `grow_output_slot()` (`:1126-1137`), one `cudaMallocHost` +per slot, guarded by `if (n_frames <= m_output_slot_capacity[slot]) return;`. Its cost +is a first-touch tax on page-locked memory, paid by whoever triggers it, and **it is not +paid again** while the batch shape holds. + +**Pageable, once per frame** — this line, inside `materialize_slot()`: + +```cpp +results[frame_idx].resize(n_found); // <-- the per-frame allocation +std::memcpy(results[frame_idx].data(), src, n_found * sizeof(ClusterType)); +``` + +Each `ClusterVector` allocates its own buffer, so every frame asks the allocator for a +fresh block — 467 kB at 9×9 — and then first-touches it. **That** is the term that +scales with frame count, and it is what makes the host loop *allocation*-bound rather +than bandwidth-bound. Its cost lands inside `collect()`, i.e. inside the caller's timed +region. + +opt6 deletes the second one entirely: `collect_view()` hands back a view into the pinned +buffer, so there is nothing to allocate and nothing to copy. + +### Q. Which copy are we actually measuring — the `memcpy` in `materialize_slot()`, or the Python-side `extend()`? + +**The `std::memcpy` (and the `resize` that precedes it).** The Python-side accumulation + +```python +clusters_cuda_per_frame.extend( + cf_cuda.find_clusters_batched(data[start:stop], first_frame=start)) +``` + +is *outside* what opt5-vs-opt6 compares. It appends already-constructed `ClusterVector` +objects to a Python list — pointer-shuffling and refcount work on objects that +`find_clusters_batched` has already returned. It moves no cluster payload. + +The host term the deck talks about is entirely inside `find_clusters_batched`: + +``` +collect(tok) + └─ finish_slot() cudaEventSynchronize — waiting for the GPU, not copying + └─ materialize_slot() per frame: resize() ← allocate + first touch + memcpy() ← the H2H copy +``` + +So when the slides say "~62 µs of malloc-and-copy per frame at 9×9", that is those two +lines, summed over the chunk and divided by frames. Keeping the accumulation out of the +timed region is deliberate; a benchmark that includes it is measuring the harness. + +Worth stating plainly because it is the usual objection: the H2H copy is **not** a +device transfer and **not** a Python cost. It is one memcpy between two host buffers — +pinned to pageable — that exists only because the caller wants to own the memory. + +--- + +## 2 · Overlap, slots, and why more of them does not help + +*(slides 17–18)* + +### Q. If two slots leave the GPU idle, wouldn't three fix it? + +No, and the argument is a standard queueing result rather than a measurement. + +**With producer period G and consumer period H, an N-buffer pipeline has steady-state +period `max(G, H)` for every N ≥ 2.** Buffers *decouple* two stages; they do not speed +up either. Depth beyond 2 only helps when the periods **vary** — it absorbs jitter, at +the cost of latency and pinned memory. Here the work per chunk is near constant, so +there is no jitter to absorb. + +The figure on slide 18 makes it visual: the host lane is byte-identical in the 2-slot +and 3-slot strips because it is already back-to-back. The third slot lets the GPU +front-load instead of stalling between chunks — the idle moves, it does not shrink — +and both strips cross the same finish line. + +The concrete version usually lands better than the theorem: **a third slot needs +somebody to fill it, and the only host thread is inside `collect()`.** Adding slots +without adding a producer is adding storage to a queue that is not storage-bound. + +### Q. Then would a producer thread help? The host end is serial, after all. + +It was tried and reverted; the comment survives at `ClusterFinderCUDA.hpp:130-136`. + +A producer thread would let submit and collect overlap, but the host term is dominated +by **malloc + first touch**, which is allocator-serialised anyway. Measured: **2.27 M +faults at 8 threads against 9.7 k at 1**, for a 6 % gain at best and a **33 % loss** +when results are freed promptly — extra threads get their own glibc arenas, which +destroys heap reuse between calls and costs more in page faults than the parallel copy +saves. + +The comment ends with the right conclusion: *stop allocating per frame, do not copy +faster.* That is opt6, and it is worth ×2.21 where the thread pool was worth −33 %. + +### Q. `submit_batch` is asynchronous but `collect` is synchronous. So why not thread the *collect* side, and then more slots would pay off? + +**The premise is right, and so is the reasoning from it.** Confirmed in code: +`submit_batch` is enqueue-only in steady state — `cudaMemcpyAsync` H2D, kernel launch, +`cudaMemcpyAsync` D2H, `cudaEventRecord`, return. (Not on the *first* call, where +`sync_pedestal_to_device()` and `grow_output_slot`'s `cudaMallocHost` are both blocking.) +`collect` is the synchronous half: `cudaEventSynchronize`, then the `resize` + `memcpy` +loop. + +And the double-buffering theorem does **not** forbid what you are proposing. It says +period = `max(G, H)` for every N ≥ 2 — more *slots* cannot help because slots do not +change `H`. Making the **consumer faster** changes `H`, which is a different lever +entirely. If `H` could be driven below `G`, the pipeline would become GPU-bound and sit +on the floor. Nothing in the theory rules that out. + +**It was measured, and it lost.** The reverted experiment at `ClusterFinderCUDA.hpp:130-136` +*was* a parallel collect — a thread pool over the per-frame copy loop, exactly this idea: + +> …the work is one 467 kB malloc + first-touch per frame at 9×9, so it is +> allocation-bound rather than bandwidth-bound. Extra threads get their own glibc +> arenas, which destroys heap reuse between calls and costs more in page faults than +> the parallel copy saves — **2.27 M faults at 8 threads vs 9.7 k at 1**, for a 6 % +> gain at best and a **33 % loss** when results are freed promptly. + +The reason it fails is worth keeping, because it is not "threads are hard". `H` is +dominated by `malloc` + first touch, and glibc gives each thread its **own arena**. One +thread reuses the same freed blocks chunk after chunk and faults almost never; eight +threads each build a private heap and re-fault from scratch. Parallelising an +allocation-bound loop multiplies the very cost it is bound by. Changing the granularity +(a thread per *slot* rather than per frame) does not escape it — the same per-frame +`malloc`s happen either way. + +So the answer is: **your lever is the right one, but threads are the wrong way to pull +it.** The way to make `H` smaller is to stop doing the work, not to do it in parallel — +`collect_view()` has essentially no `H` at all, and that is worth ×2.21 where the thread +pool was worth −33 %. + +One consequence to note if you do adopt zero-copy: a held `BatchView` pins its slot, so +pipeline depth drops to `NUM_SLOTS - 1 = 1` while you read. Zero-copy trades buffer +depth for the copy — which is affordable precisely because there is no longer a long +host phase to overlap. + +### Q. What were opt3's two barriers? The slide only shows one. + +That gap is why slide 15 exists. opt3 removed **both**: + +1. The per-round `cudaDeviceSynchronize`. +2. The **count-then-fetch round trip** — copy 4 bytes, block, read the count, copy N + bytes, block. Two D2H transfers and two synchronisations per frame, replaced by one + copy of a fixed envelope with no host involvement at all. + +Barrier 2 is the reason the envelope is occupancy-blind in the first place: paying for +unused cluster slots is cheaper than asking the host how many were used. + +--- + +## 3 · The 9×9 host term, and the 66.39 µs question + +*(slides 18–19, §8.3, annex A4)* + +### Q. The opt6 slide says the host copy is ~40 µs. Where does ~62 µs come from? + +The 40 µs was **the memcpy alone, computed at bandwidth** — 467 kB at PCIe/DRAM rates. +It is a correct number for the wrong quantity: the host loop is **allocation-bound, not +bandwidth-bound**, so it undercounts the host term by roughly half. + +### Q. Isn't 66.39 µs the end-to-end frame time, not the host time? + +**Yes — and this correction is load-bearing.** An earlier draft argued: end-to-end is +`max(G, H)`, end-to-end measures 66.39, therefore H = 66.39, therefore the pipeline is +optimal. That is circular; it assumes the conclusion it then uses as evidence. 66.39 is +the end-to-end period of opt5 rep 1 and nothing more. + +The host term is **not measured directly** — nobody timed the host loop in isolation. +It is inferred, and two independent routes agree on ~62 µs. + +**Route 1 — fault correction.** opt5 at 9×9 is the one row in the ladder that never +reaches a fault-free plateau, because each rep meets a different allocator state for the +467 kB per-frame block: + +| rep | µs/frame | minor faults | fault cost @ 0.68 µs | fault-free | +|--:|--:|--:|--:|--:| +| 0 | 78.56 | 460 283 | 15.65 | 62.91 | +| **1** | **66.39** | **151 601** | **5.15** | **61.23** | +| 2 | 67.34 | 95 884 | 3.26 | 64.08 | +| 3 | 81.26 | 506 241 | 17.21 | 64.04 | +| 4 | 73.97 | 334 303 | 11.37 | 62.60 | + +The rate 0.68 µs/fault was fitted at **3×3** and applied here **out of sample**. It +collapses a **22 % raw spread into 4.6 %**, landing at 61–64 µs. A rate that had nothing +to do with the mechanism should not be able to do that. + +**Route 2 — a rep that was already warm.** In the `[f32]` arm, rep 3 happened to run +with only **10 128 faults** (0.34 µs/frame) and measured **61.85 µs** with no correction +at all — inside the corrected `[f64]` band. + +Contrast opt6 in the same file: **2 072, 0, 0, 0, 0** faults. And contrast opt5 at +**3×3**, which is clean — 30–96 k faults, 1.6 % spread. The contamination is specific to +one cell of the matrix, and its cause is exactly the allocation opt6 deletes. + +### Q. Does the correction change the conclusion? + +No. The host is the taller bar at 9×9 either way. What changes is the **margin**: it is +roughly **2× the GPU floor, not 1.3×**. Any figure drawing the 9×9 host cost at 40 µs +understates it by about half, which is why the opt5 strips and the result-path bars were +redrawn at 62. + +### Q. How would you time that row honestly? + +A fresh process per rep and a pre-touched result heap. Without both, the number that +comes out is an allocator state, not a throughput. + +Related trap: freeing a ~10 GB result heap hands it back to the allocator and a +subsequent loop reuses it. On a cold heap the first loop pays the entire first-touch tax +and any printed ratio is meaningless. Both loops must be at plateau, and stale result +bindings must be dropped before timing. + +--- + +## 4 · Pedestal timing — serial, frozen, and CUDA + +*(slides 29–31, annex A7)* + +### Q. What is the actual difference between `ClusterFinder` and `ClusterFinderFrozen`? + +**Exactly one thing: when the pedestal is pushed.** The serial CPU finder updates the +pedestal *as the raster passes each pixel*, so a decision late in the frame is taken +against a pedestal that already contains this frame's earlier pixels. Frozen and CUDA +both decide against the **frame-start snapshot** and apply every update at the frame +boundary. + +That makes the comparison factorable: `cpu vs frozen` isolates update **timing** with +the arithmetic held fixed, and `frozen vs cuda` isolates the **port** with the timing +held fixed. Comparing CUDA straight to the serial CPU confounds the two. + +### Q. In the serial finder, can a pixel updated mid-frame ever affect a later decision? + +Yes — through the **stencil**, never through the update itself. The distinction matters +and is easy to get backwards. + +```cpp +void push_fast(const uint32_t row, const uint32_t col, const T val_) { + SUM_TYPE val = static_cast(val_); + m_sum(row, col) += val - m_sum(row, col) / m_samples; + m_sum2(row, col) += val * val - m_sum2(row, col) / m_samples; + m_mean(row, col) = m_sum(row, col) / m_samples; +} +``` +(`Pedestal.hpp:215-222`) + +`push_fast` touches **only the pixel's own accumulators** and never reads a neighbour. +So the update is **order-independent**: given the same *set* of updated pixels, serial +and frozen end a frame with a bit-identical pedestal. There is no accumulation +asymmetry to find. + +The only channel for divergence is therefore a differing **decision** — and decisions +read the 3×3 stencil, which in raster order is half in the past (already possibly +pushed this frame) and half in the future (cannot be). + +### Q. Which of the three tests is actually exposed to that? + +All three can flip, but they are not equally exposed and they do not cost the same: + +The 974 divergent pixels partition onto the three decisions with no remainder, and +the partition is the argument in one table: + +| | reads | flips | clusters it explains | +|---|---|--:|--:| +| Test 1 | the stencil **max** | **619** | **0** | +| Test 3 | the stencil **sum** | 347 | 11 (all `frozen-only`) | +| local-max gate | two stencil values | 8 | 8 (all `cpu-only`) | +| | | **974** | **19** | + +Test 3 collects the shift of *every* already-scanned neighbour — three above and one +left — where Test 1 feels at most the one that happens to be the argmax. That is why +the sum is the sensitive statistic. + +Test 1 flips **most often and costs nothing**: a Test 1 flip moves a pixel between +`QUIET_UPDATE` and `SHADOW`, and neither of those stores. No cluster appears or +disappears; it only changes whether that pixel pushed, which feeds forward. + +### Q. Can you prove Test 3 is the channel, rather than just argue it? + +Two independent experiments, both in `python/tests/`. + +**Instrumented** (`branch_trace.py` — both finders run their shipped logic, each records +a per-pixel branch code, the maps are diffed frame by frame). 974 pixels out of 1.6 × 10⁹ +take a different branch, and the ones that change the cluster set decompose onto the +8/11 headline with **no remainder** (`cpu` finds 23 244 602 clusters, `frozen` +23 244 605): + +``` +frozen-only 11 = QUIET_UPDATE -> TEST3_STORE (all Test 3) +cpu-only 8 = TEST3_STORE -> TEST3_SKIP (5) (local-max gate) + + TEST1_STORE -> SHADOW (3) +``` + +**Ablated** (`AARE_TEST3_ENABLED = 0`, Test 3 compiled out of **both** finders): + +| | Test3 ON | Test3 OFF | +|---|--:|--:| +| clusters (cpu) | 23 244 602 | 23 241 342 | +| divergent pixels | 974 | 584 | +| first divergence | frame 4 | frame 30 | +| frozen-only | 11 | **0** | +| cpu-only | 8 | 4 | + +The 11 go to zero exactly. + +### Q. Why does `cpu-only` go 8 → 4 rather than 8 → 8, if Test 3 is not involved in those? + +Because ablating changes **which pixels push**. The pedestal then follows a different +path and the downstream ties are a different realisation. The *kind* is preserved — all +4 remaining are `TEST1_STORE → SHADOW`, the local-max gate — but the count is not, and +should not be expected to be. + +### Q. So Test 1 is just downstream of Test 3? + +**No — that was predicted and the measurement refuted it.** With Test 3 off, the first +divergence is still a Test 1 flip at frame 30, and *nothing diverged before it*, so the +two pedestals were provably identical when it happened. Test 1 initiates on its own. It +is simply ~7× slower to do so (frame 30 against frame 4) and **cannot create a cluster +by itself**. + +### Q. Is the instrumentation in the shipped path? + +No. `AARE_BRANCH_TRACE` defaults to **0** and every write folds away at compile time, so +the CPU baseline whose throughput the deck quotes is unaffected. `AARE_TEST3_ENABLED` +defaults to 1. Both live in `ClusterFinder.hpp` and `ClusterFinderFrozen.hpp`; both test +scripts document the rebuild. With tracing off, `branch_map` reads all-5 (`UNTOUCHED`). + +--- + +## 5 · The three tests, and `c3` + +*(slide 4, annex A7 · 1/2)* + +### Q. Slide 4 says "the whole algorithm" and shows two tests. Is that all of them? + +No — there are three, and A7 · 1/2 exists to say so. Slide 4's simplification is right +for the arc there (the point is the *three outcomes* shape: store, shadow, update), but +it is not complete. + +``` +v = frame[i] - ped_mean[i]; rms = ped_rms[i] +if (v < -nSigma*rms) -> skip, no update +m = max over the 3x3 window +total = sum over the 3x3 window +if (m > nSigma*rms) // TEST 1 + if (v == m) -> emit cluster // local-max gate + else -> shadow, no update +else if (total > c3*nSigma*rms) // TEST 3 + if (v == m) -> emit cluster +else -> update pedestal +``` + +The negative-value skip is a fourth branch but not a test in the same sense — it drops +pixels far *below* pedestal, which are detector artefacts rather than photons, and it +does not update either. + +### Q. Where does `c3 = 3` come from? Is it tuned? + +It is not tuned. It falls out of **variance addition**. + +Test 1 asks whether one pixel is 5σ above **its own** noise. Test 3 asks the same +question of the **sum** of nine pixels — so all that is needed is the noise on that sum: + +``` +Var(v₁ + … + v₉) = Var(v₁) + … + Var(v₉) = 9σ² (independent samples) +σ_sum = √(9σ²) = 3σ +``` + +**Standard deviations do not add; variances do.** That is the entire content of the +square root: nine pixels give nine times the variance but only three times the rms, so +a threshold on the sum has to be 3× larger to carry the same 5σ meaning. Hence +`c3·nSigma·rms` is the *same criterion as Test 1, asked of the window instead of the +pixel*. + +`c3 = sqrt(ClusterSizeX * ClusterSizeY)` in the constructor, so it generalises: at 9×9 +it is `√81 = 9`. + +### Q. Why bother summing at all? + +Same algebra, read the other way: for a photon genuinely spread over the window, the +**signal adds linearly (×9) while the noise adds in quadrature (×3)** — a net √9 = 3× +gain in signal-to-noise. Test 3 catches a photon whose charge is shared out so widely +that no single pixel reaches 5σ, but the nine together do. + +### Q. Doesn't that assume the noise is uncorrelated? + +It does. What is being added is the **pedestal** noise, which is per-pixel readout noise +and uncorrelated between pixels to a good approximation. Correlated noise would need +covariance terms and would push `c3` **above** `√N`. + +--- + +## 6 · Reading the annex A7 figure + +### Q. Why does a photon look 3×4 pixels wide? Clusters are 3×3. + +It doesn't — that is the shadow, and shadow is not the photon's 3×3. + +> **Shadow is every pixel whose *own* 3×3 window contains something above 5σ.** + +Crucially, **a shadow pixel need not be bright itself.** The condition is `m > 5σ` (the +*window's* max clears) and `v != m` (this pixel is not the peak). Three tiers, all +present at the site on the slide, against a 5σ bar of 85.5 ADU: + +| ADU | branch | why | +|--:|---|---| +| 810.3 | **stored** | it *is* the window max | +| 345.0 | shadow | above the bar, but not the peak | +| 17.7 | shadow | nowhere near the bar — but its 3×3 reaches the 345 | + +So charge shared across two adjacent pixels lights up the **union of every window that +can see either of them**, which is how a region reaches 3×4. In that 21×21 patch, 27 +pixels clear the site's 85.5 ADU bar, 9 are local maxima, and 98 end up shadowed. + +### Q. Why are the frozen numbers red rather than amber? + +So that **amber means one thing in both panels**: a pixel that pushed the pedestal. On +the left it is the ~80 % sample class; on the right it is the ring around the four +already-scanned neighbours — and those four *are* pedestal samples, so the two uses +agree rather than collide. Frozen therefore takes red and serial keeps blue. Neither is +colour-alone: the frozen row is labelled and always sits above the serial row. + +### Q. There's a lone shadow pixel below the site with amber on both sides. How? + +Image pixel **(129, 245)**, four rows below the disputed pixel. It is the cleanest +illustration on the slide of something the algorithm does that is easy to forget. + +Values (pedestal-subtracted), rows 128–130: + +| | col 244 | col 245 | col 246 | +|---|--:|--:|--:| +| row 128 | 40.5 | −1.5 | −4.0 | +| **row 129** | **31.5** *(sample)* | **7.2** *(shadow)* | **−18.5** *(sample)* | +| row 130 | **85.2** | 2.6 | 11.2 | + +Both (129, 244) and (129, 245) have windows that contain the 85.150 ADU pixel at +(130, 244) — it is one row down and one column left, so it sits in both. Their window +maxima are **identical: 85.150**. The right-hand neighbour (129, 246) has a window max +of only 16.958 and is a sample for uninteresting reasons. + +So why do two pixels reading the *same* maximum take *different* branches? + +**Because the 5σ bar is per-pixel.** The test is `m > nSigma * rms[centre]`, using the +noise of the pixel being tested, not a global constant. 85.150 lands right on the bar +(5 × 17.101 = 85.5 at the site), so a percent of rms variation decides it. From the +branch codes alone one can bound the two: + +``` +rms(129, 245) < 17.030 ≤ rms(129, 244) +``` + +The left neighbour is *noisier*, so its bar is higher, so the same 85.150 fails to clear +it. Same evidence, different threshold, different answer. + +Two things worth noticing while it is on screen. First, the 85.2 pixel at (130, 244) is +itself only a **sample** — it is its own window's max, but 85.2 does not clear its own +5σ bar and its window sums to 119.5, well under the ~256 Test 3 threshold. A pixel can +shadow a neighbour without being bright enough to be anything itself. Second, this is +the *same knife-edge* as the headline result: the disputed pixel differs by 0.09 ADU on +a threshold of 256.511. Near-threshold pixels are where every CPU/CPU disagreement +lives. + +*(The dump carries no per-pixel rms map, which is why the bound above is a bound rather +than two printed numbers. `branch_site_dump.py` can be extended to record it.)* + +### Q. Why is the left panel's marked pixel amber with a green ring, rather than green? + +Because the panel is coloured by the **serial** finder, and serial *sampled the pedestal* +there — only frozen stored. Painting it plain green would read better and contradict the +Σ lines beside it. + +### Q. Why do the two panels show different moments? + +Deliberately, and each says so. The left is the **finished frame**: the branch map is +read once `find_clusters()` returns, so all 441 cells carry a final decision and the +arrows mean raster *order*, not progress. The right is **the instant the centre pixel +was tested**, which is the only moment at which the two models can be said to disagree — +four of its neighbours are in the raster's past and may already carry this frame's push, +four are in its future and cannot. + +--- + +## Sources + +| what | where | +|---|---| +| every quoted rate, fill, and fault count | `docs/ClusterFinderCUDA_benchmark_results.md` | +| the non-plateau row and the ~62 µs derivation | §8.3 | +| result-path code | `include/aare/ClusterFinderCUDA.hpp` | +| pedestal update | `include/aare/Pedestal.hpp:215` | +| the three tests | `include/aare/ClusterFinder.hpp:104-142` | +| branch decomposition | `python/tests/branch_trace.py` | +| the site dump behind the A7 figure | `python/tests/branch_site_dump.py` | diff --git a/docs/deck/README.md b/docs/deck/README.md index 087561ef..46589ca9 100644 --- a/docs/deck/README.md +++ b/docs/deck/README.md @@ -3,7 +3,7 @@ `docs/cf_cuda_performance.pptx` — kernel design, hardware limits, and the opt1→opt7 optimization ladder, told in three acts ordered by which bar is tallest. -35 numbered slides plus a 6-group annex, 53 pages once dividers and the title page +35 numbered slides plus a 7-group annex, 55 pages once dividers and the title page are counted. ## Build @@ -92,5 +92,7 @@ report: opt5 at 9×9, whose per-frame allocation never lets the fault count conv | `build_performance_deck.py` | the deck: tokens, helpers, every slide | | `make_figs.py` | most figures, plus the legibility gate | | `make_figs_kernel.py` | `fig_frame`, `fig_occupancy`, `fig_tile` | +| `QA.md` | questions the room asks, with the answers and where they are settled | | `frame147.json`, `validation_tiers.json` | measured data two figures read | +| `branch_site.json` | the A7 site dump; written by `python/tests/branch_site_dump.py` | | `CHANGELOG_2026-08-*.md` | dated records of past revisions; they keep the file names in use on those dates | diff --git a/docs/deck/branch_site.json b/docs/deck/branch_site.json new file mode 100644 index 00000000..16625a91 --- /dev/null +++ b/docs/deck/branch_site.json @@ -0,0 +1,1583 @@ +{ + "frame": 203, + "iy": 125, + "ix": 245, + "n_sigma": 5, + "c3": 3.0, + "raw": [ + [ + 4460.0, + 4461.0, + 4376.0 + ], + [ + 4461.0, + 4582.0, + 4392.0 + ], + [ + 4463.0, + 4541.0, + 4451.0 + ] + ], + "ped_cpu": [ + [ + 4428.362910585158, + 4475.405456375104, + 4342.270466162139 + ], + [ + 4419.362167080695, + 4525.527419531644, + 4361.992883395069 + ], + [ + 4447.785996280896, + 4500.783468558215, + 4429.020731723249 + ] + ], + "ped_frz": [ + [ + 4428.331241826984, + 4475.419876251356, + 4342.236702865004 + ], + [ + 4419.320487568263, + 4525.527419531644, + 4361.992883395069 + ], + [ + 4447.785996280896, + 4500.783468558215, + 4429.020731723249 + ] + ], + "val_cpu": [ + [ + 31.637089414842194, + -14.405456375104222, + 33.7295338378608 + ], + [ + 41.637832919304856, + 56.47258046835577, + 30.00711660493107 + ], + [ + 15.214003719103857, + 40.216531441785264, + 21.9792682767511 + ] + ], + "val_frz": [ + [ + 31.668758173015704, + -14.419876251356072, + 33.76329713499581 + ], + [ + 41.67951243173684, + 56.47258046835577, + 30.00711660493107 + ], + [ + 15.214003719103857, + 40.216531441785264, + 21.9792682767511 + ] + ], + "scanned": [ + [ + true, + true, + true + ], + [ + true, + false, + false + ], + [ + false, + false, + false + ] + ], + "rms_cpu": 17.100731620366265, + "rms_frz": 17.100731620366265, + "total_cpu": 256.4885003078307, + "total_frz": 256.58119199931934, + "max_cpu": 56.47258046835577, + "max_frz": 56.47258046835577, + "value_cpu": 56.47258046835577, + "value_frz": 56.47258046835577, + "thr_test1_cpu": 85.50365810183132, + "thr_test1_frz": 85.50365810183132, + "thr_test3_cpu": 256.51097430549396, + "thr_test3_frz": 256.51097430549396, + "branch_cpu": 4, + "branch_frz": 3, + "patch": { + "r": 10, + "y0": 115, + "x0": 235, + "val": [ + [ + 319.79361653683463, + 7.774178833213227, + 15.657109931747982, + 9.174055354302254, + 12.276449703674189, + -12.463942541519828, + 37.63465287577674, + 12.891218618950006, + -0.6692921831208878, + 13.590359436163453, + -11.504722827477963, + 36.80476959438329, + 1.3513369731581406, + 33.940059758389, + -8.654314739212168, + -32.84133563287014, + 1.244335541991859, + 3.0134293898399847, + 828.9528213791446, + 26.38650273452913, + 4.926644116099851 + ], + [ + 286.99671926258816, + -9.955745757140903, + 20.78026637797302, + 19.14097424627471, + 6.330712167142337, + 8.660815187455228, + 16.78703963863063, + -3.856478511993373, + -16.261114832464045, + 0.4438977386826082, + -25.607921949994306, + 2.162980328204867, + -8.398907692566354, + -6.234963659084315, + 2.089441144072225, + -31.841624473179763, + -5.622300276005262, + -15.018593617697661, + 318.9585926769669, + 6.592424587644018, + 17.65649237184607 + ], + [ + -1.5170625644404936, + -10.86117794978054, + 16.925466295977458, + -5.163288104528874, + 8.78874747808186, + -5.100122602585543, + 36.55980625217944, + 14.65131240516348, + 8.732674004592809, + 12.021483639145117, + -0.11889365719525813, + 9.476589358488127, + -3.7736367424085984, + 7.01244506981584, + 0.16041935831617593, + -12.419713404055074, + -17.61450165153383, + 638.2514989430902, + 146.05019890732274, + -5.8633962449112005, + 15.948595498503892 + ], + [ + -1.434320271294382, + -10.06424494949897, + 6.131203107410329, + 23.830147711223617, + 30.164660191258918, + 17.454068079669014, + 31.370836934600447, + -9.428608486151461, + 6.575075104299685, + 17.08822395451898, + 21.183093657754398, + -24.571782731239182, + -0.5502814368328472, + -9.915292648913237, + -7.263933309033746, + -36.9143556272511, + -9.544487457404102, + 390.6946885624038, + 98.28513847149134, + 0.3138302470188137, + -6.551237125815533 + ], + [ + 51.81455326406012, + -0.6830816765086638, + -27.058965793038624, + -6.707232443744942, + 26.419967468158575, + 17.07463134063346, + 24.750974880144895, + 7.75193201476759, + 0.6044368569191647, + 44.870659695838185, + -2.1653321536450676, + 11.7058274437195, + 10.631895924631863, + 15.379928493321131, + 26.63754895022703, + -10.195445169884806, + -18.447250495589287, + 25.61743067986754, + -20.158074939408834, + 52.99675476926586, + 43.17806425832168 + ], + [ + 18.043383844579694, + -6.454234002985686, + 39.069824126944695, + 5.706140554391823, + 9.777155936206327, + 14.996536533246399, + 27.64586265617345, + 21.280474939007945, + 3.3901485804608456, + 43.10070722459659, + 4.530369289124792, + -2.0146474720222614, + -25.504764814074406, + -13.297096269721806, + 20.02889844364927, + -4.469667542035495, + -5.733110184547513, + -4.206362023939619, + 8.947560731000522, + 44.179298530726555, + -14.89734812203642 + ], + [ + 45.99697170367108, + 7.840150171797177, + 42.71850282719515, + -2.512526444635114, + -16.144289259599645, + 2.336004534442509, + 13.892849791952358, + 11.205302915454013, + -7.219841381076549, + 22.517637975568505, + -24.644613764501628, + -12.064288468991435, + -1.311484895427384, + -18.33216717231153, + 47.140350925257735, + -7.565209282456635, + -14.903834318845838, + 184.63993180580837, + 886.7120386857559, + 13.527493133176904, + 11.518033033263237 + ], + [ + -14.747604088960543, + -17.02059963868396, + 25.816196784475324, + 1.3534092391528247, + 46.18679525112384, + 21.94076589898941, + 14.580873238611275, + -15.902570202202696, + -9.712955699430495, + 11.978697518714398, + 3.540071538312077, + -14.151137929328797, + -2.811796207752195, + 19.202647841704675, + 6.304235626644186, + 11.841501978536144, + -0.3681926482322524, + 60.91452704657058, + 126.89795976820278, + 12.210518952912025, + 23.13126687685417 + ], + [ + 4.668084751223432, + 11.281120726108384, + -6.294141984980342, + 15.380302541540914, + 39.550713154301775, + -31.119537792430492, + 28.560463229339803, + -14.415852678464034, + 2.7762647661584197, + 39.32078875338357, + 24.370928350791473, + 31.384430668262212, + -5.874197659532911, + 11.070733068268964, + -37.080259201360604, + 5.310787288377469, + 3.9066794886248317, + -5.2995618549330175, + 23.87522507308313, + -5.407816470346916, + -17.50124845789469 + ], + [ + 2.7467243982946457, + 11.994116522115291, + 8.361386410753767, + 3.3895092924731216, + 32.88573248035664, + -10.461339400109864, + 28.7286020680167, + 4.968074042417356, + 21.482269484829885, + 31.668758173015704, + -14.419876251356072, + 33.76329713499581, + -35.92942445310564, + -5.272115586394648, + -2.0586046080015876, + -18.274619090274427, + -9.772224943463698, + -36.210441308268855, + -7.883454863083898, + 55.080537173274934, + 0.15437704166470212 + ], + [ + 26.463246277568032, + -1.6032929061111645, + 27.125389347070268, + -7.822603950976372, + 13.72429721129447, + 11.292470922578104, + 3.2587369746624972, + 3.873700631994325, + -10.312793600873192, + 41.67951243173684, + 56.47258046835577, + 30.00711660493107, + 15.236609571260487, + -3.983117654985108, + -0.6030881662354659, + 1.3336933305163257, + 10.22107821719419, + -6.874491356146791, + -21.6066593712967, + -20.523282511339858, + 37.28802709165302 + ], + [ + -32.411747361837115, + -19.35587970421784, + -9.201511426624165, + 46.72181206995083, + 14.131257476010433, + -43.03000897108359, + 28.61445126113631, + -12.37872350372254, + 45.10884702344629, + 15.214003719103857, + 40.216531441785264, + 21.9792682767511, + -13.619689446909433, + 4.056459092669684, + -6.8607252041711035, + 2.7100500786200428, + -17.679653712998515, + 31.904076496608468, + 29.77461544137259, + -14.813640928880886, + 7.304511723644282 + ], + [ + 21.584487595784594, + 1.5203005945786572, + 7.949840246319582, + 7.493931802386214, + 25.85140967231746, + 0.19624434439720062, + 17.705960005957422, + 345.0084227579973, + 810.2806037007795, + 25.77760003610365, + 18.870223682817596, + 8.94371510242945, + -29.56505153699709, + -38.805310699051915, + 22.733351394739657, + -8.2978579831979, + -30.679393232624534, + 14.74095696798031, + 4.641040075322053, + 20.97823546332802, + -4.172786115992494 + ], + [ + -15.219270547723681, + -0.38593709860197123, + 11.280103827557468, + 8.949688204666927, + -38.51000952878712, + -36.94552681470668, + 26.868389984104397, + 29.43047764087987, + 66.42587235452902, + 40.49869673059766, + -1.549700761483109, + -3.9900346103568154, + 16.95829946376398, + -9.839609435131024, + 848.0411337916285, + 167.49535490230937, + 18.269174373586793, + 16.030968485139056, + -29.38153347061325, + 15.066168430562357, + 8.36609377185141 + ], + [ + 1.6898792707306711, + 18.67235945532684, + -12.126363710017358, + 2.086196277597992, + -18.521382163027738, + 22.716957189085406, + 8.357586677067957, + -9.775560224639776, + -14.228696916474291, + 31.514789614532674, + 7.247424140096882, + -18.467596078672614, + -6.35522545294225, + -13.895267157300623, + 71.43190026329648, + 9.604846942467702, + -32.96890946868007, + -25.665985559509863, + -5.191936788602106, + -6.495023736179064, + 112.9756965686338 + ], + [ + 559.8558044451165, + 480.887446049941, + -6.374121077910786, + 19.87981189794573, + 32.32388118443396, + -21.888185908974265, + 222.60599098455532, + 606.4008093866742, + -27.123557624171553, + 85.1502926677058, + 2.5931495912536775, + 11.248678806696262, + -19.115029127970047, + 16.318687726082317, + -37.15840182215561, + -12.42436810914296, + 3.0438715686941578, + 41.70788662261202, + 33.02656838923485, + -3.1301139395554856, + 95.7752125042798 + ], + [ + 66.99120260678956, + 94.42071279494576, + 7.083683841535276, + -5.337193029956325, + 44.04980803214403, + -23.626089469749786, + 99.37327409799218, + 278.57042935653226, + -9.153894102312734, + 33.47546084150872, + 9.999644755749614, + 19.382134216977647, + 35.25555381875711, + 7.595883102892913, + 9.979060322792066, + 2.224981530038349, + -29.452826725451814, + 12.686056028612256, + 27.203585286620182, + -4.611486457078172, + 19.165633730728587 + ], + [ + 28.034218216035697, + 17.97322318746683, + 2.298619708441038, + 32.178437120108356, + -0.5495541317322932, + 2.976801708245148, + -7.988442881309311, + 8.71350090962369, + 9.566408678600965, + 21.16593814252974, + 9.825751863664664, + 15.325506233446504, + -2.8671801538048385, + 1.0796584265171987, + 3.3854864314453152, + 6.382522486527705, + 12.166892715010363, + 16.312653949617925, + 14.69602848363229, + 45.20404710140156, + 30.275933719684872 + ], + [ + -7.491320118840122, + 23.56195130413562, + 17.693997785801002, + -5.516188300308386, + 26.695319590981853, + -2.75473458489887, + 15.69121382558842, + 34.85033916128123, + -7.828561995695964, + 19.562939990487394, + 27.499708011837356, + 5.957857620785944, + -32.67984203377, + 10.506065486493753, + 14.473719456928848, + -22.047067074514416, + 0.9573057043289737, + -10.953291853996234, + -13.659236730167322, + 12.540806295478433, + 3.5030120684878057 + ], + [ + 32.71361042753597, + 2.1209678939167134, + 7.820462613973177, + 7.310262076856816, + 72.22327328566917, + 249.7592124853054, + 2.5453734498523772, + -9.597577117817309, + -20.406731883981593, + 21.145533411644465, + 8.86830177234151, + 22.966156676387072, + 7.340151660164338, + 0.31179150926800503, + -8.704699551054546, + 0.9947463451471776, + 26.202031495074152, + 31.0248203741412, + -19.244984531565024, + 2.527415496660069, + 2.056726665910901 + ], + [ + 17.164465151496188, + -18.38237829343325, + 6.815282776608001, + -2.327084038826797, + 96.65006048993564, + 717.05123660357, + 15.34398992612114, + 4.819378996417072, + 13.0279909955525, + 15.121650674516786, + -2.999588907459838, + 18.206299795861014, + 22.433367517962324, + 1.4984477476291431, + -7.4325118779170225, + 13.181849490907553, + 19.59772490600608, + 0.42593354042764986, + -18.325816077129275, + 13.411881841817376, + 5.89494109214138 + ] + ], + "branch_cpu": [ + [ + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 2, + 1, + 1, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 6, + 1, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + ], + "branch_frz": [ + [ + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 3, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 2, + 1, + 1, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 6, + 1, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + ] + } +} \ No newline at end of file diff --git a/docs/deck/build_performance_deck.py b/docs/deck/build_performance_deck.py index 4b5ce7a2..4ab6a8c3 100644 --- a/docs/deck/build_performance_deck.py +++ b/docs/deck/build_performance_deck.py @@ -192,7 +192,7 @@ def chrome(s, idx, eyebrow, title, title_size=27): run(para(tf, True, align=PP_ALIGN.RIGHT), f"{idx} / {n}", 8.5, MUTED) -N_ANNEX = 6 # annex GROUPS, not slides +N_ANNEX = 7 # annex GROUPS, not slides def annex_chrome(s, grp, eyebrow, title, part=None, nparts=None, title_size=27): @@ -1309,7 +1309,7 @@ bullets(s, M, 1.84, 11.9, [ "against 30.01 µs of GPU — so overlap still works, it just has less to hide. " "That is why opt5 is worth **×1.20** here and ×1.31 at 3×3.", ], size=10.5) -figure(s, "fig_overlap_9x9", M + 0.15, 2.52, 11.3) +figure(s, "fig_overlap_9x9", M + 0.15, 2.44, 11.3) callout(s, M, 6.30, 11.9, "A deeper buffer **relocates the GPU's idle, it does not close it** — the " "host lane is already back-to-back in both strips, so it alone sets the " @@ -1877,6 +1877,34 @@ caption(s, M, 6.58, 11.9, "re-running python/tests/ClusterFinderFrozen_vs_CUDA.ipynb, which counts and " "localises every disagreement rather than only totalling them.") +notes(s, """Row 1 and row 2 are the same 8/11, which is the point: everything +CUDA changes is worth zero, and the whole residual is a CPU-vs-CPU effect. + +WHICH TEST the timing moves is measured in annex A7, and the answer is specific: + + frozen-only 11 clusters -> ALL from Test3 (total > c3*nSigma*rms) + cpu-only 8 clusters -> ALL from the local-max gate (value == max) + Test1 threshold -> contributes ZERO clusters + +Test1 and the local-max gate are protected by construction: any pixel above +nSigma*rms is never updated inside the frame (it is a centre or in shadow, and +neither branch pushes), so the stencil argmax is always pristine. Test3 sums all +nine values, and the four already-scanned neighbours -- three above, one left -- +are exactly the pixels eligible for update. + +Confirmed two ways: instrumented (branch codes diffed per frame) and ablated +(Test3 compiled out, at which point the 11 go to zero exactly). A7 has both. + +Test1 flips MORE often than Test3 -- 619 of 974 divergent pixels -- and costs +nothing, because it only moves a pixel between QUIET_UPDATE and SHADOW and +neither of those stores. It is not merely downstream of Test3 either: with Test3 +ablated the first divergence is still a Test1 flip, on a frame where the two +pedestals were provably identical. Test1 initiates on its own, just ~7x slower +(frame 30 vs frame 4), and can never create a cluster by itself. + +Row 4 is a different mechanism entirely -- f32 EMA drift, not timing, since both +finders freeze the pedestal there. That is the next slide.""") + # ================================================ 28 · THE MISMATCH, SEEN s = new_slide() chrome(s, 31, "Validation · the disagreement, seen", @@ -2133,9 +2161,10 @@ section("", ("A3", "opt5 · the overlap code"), ("A4", "The fault model, tested"), ("A5", "The variance rewrite in full"), - ("A6", "The three benchmark artefacts")], + ("A6", "The three benchmark artefacts"), + ("A7", "Which test causes the CPU/CPU gap")], rng=(1, N_ANNEX), col=AMBER, annex=True, - carry=("Everything so far", "33 slides", + carry=("Everything so far", "35 slides", "the arc is finished; what follows answers questions")) # =========================================================================== @@ -2590,5 +2619,202 @@ budget in A2, and it is quoted to a single significant figure for exactly this reason: a ~4x inflated host-call time can support "launch cost is about 2 us, against a 24 us floor", and nothing finer than that.""") +# ============================================ ANNEX A7 · WHICH TEST, MEASURED +# Two slides. Slide 4's code panel is titled "THE WHOLE ALGORITHM" but shows a +# two-test simplification -- Test3 is not in it. So part 1 has to put the third +# branch back before part 2 can blame it for anything. +s = new_slide() +annex_chrome(s, 7, "the three tests · completes slide 4", "There is a third test", + part=1, nparts=2) +bullets(s, M, 1.80, 11.9, [ + "Slide 4 showed the decision with **two** tests, which is the right " + "simplification for the arc. The finder has **three**, and the missing one " + "is what the next slide is about.", +], size=10.5) +code(s, M, 2.48, 7.3, [ + "v = frame[i] - ped_mean[i]; rms = ped_rms[i]", + "if (v < -nSigma*rms) -> skip, no update", + "m = «max» over the 3x3 window", + "total = «sum» over the 3x3 window", + "if (m > «nSigma»*rms) // TEST 1", + " if (v == m) -> emit cluster // local-max gate", + " else -> shadow, no update", + "else if (total > «c3*nSigma»*rms) // TEST 3", + " if (v == m) -> emit cluster", + "else -> update pedestal", + "", # code() budgets 0.0174 in/pt but LibreOffice sets Consolas at ~0.0187, + # so a 10-line panel clips its last descender. One blank line buys the + # slack without touching the constant every other panel depends on. +], size=9, title="ClusterFinder.hpp:104-142 · all three branches") +rail(s, [ + ("label", "what each test asks"), + ("gap", 0.12), + ("row", "Test 1 · nSigma · rms", "is any ONE pixel bright?", ACCENT), + ("gap", 0.12), + ("row", "Test 3 · c3 · nSigma · rms", "is the WINDOW bright?", AMBER), + ("gap", 0.12), + ("row", "local-max gate", "is this pixel the peak?", PALE), + ("gap", 0.18), + ("note", "Test 1 reads the MAX of the window; Test 3 reads its SUM. That " + "one difference is the whole of the next slide."), +], y0=2.15) +callout(s, M, 5.86, 11.9, + "**c3 = √(3×3) = 3 is not a fudge — it falls out of variance addition.** " + "For independent samples the variance of a sum is the sum of the " + "variances, so a 3×3 window of pixels each carrying noise σ gives " + "**Var(Σ v) = 9σ²**, i.e. a sum whose noise is **√9 · σ = 3σ**. Requiring " + "that sum to clear nSigma of ITS OWN noise is exactly **c3·nSigma·rms** — " + "the **same 5σ criterion as Test 1, asked of the window instead of the " + "pixel**. So Test 3 catches a photon whose charge is shared out so widely " + "that no single pixel reaches 5σ, but the nine together do.", + h=1.10, size=10.5) +caption(s, M, 7.02, 11.9, + "Roughly 80 % of pixels reach the last branch and push the pedestal; " + "~1.5 % are peaks and ~18 % sit in a peak's shadow.", size=9) +notes(s, """Why slide 4 leaves Test3 out: at 3x3 it is a small correction to the +cluster count, and the arc's point there is the THREE OUTCOMES shape -- store, +shadow, update -- not completeness. This slide is where completeness belongs. + +Read c3 out loud, it is the part people find satisfying. Test1 asks whether one +pixel is 5 sigma above ITS OWN noise. Test3 asks the same question of the SUM of +nine pixels -- so the only thing needed is the noise on that sum, and that is +just variance addition: + + Var(v1 + ... + v9) = Var(v1) + ... + Var(v9) = 9 * sigma^2 (independent) + sigma_sum = sqrt(9 * sigma^2) = 3 * sigma + +Standard deviations do NOT add; variances do. That is the whole content of the +sqrt: nine pixels give nine times the variance but only three times the rms, so +a threshold on the sum has to be 3x larger to carry the same 5-sigma meaning. +It is also why summing helps at all -- the signal adds linearly (x9) while the +noise adds in quadrature (x3), a net sqrt(9) = 3x gain in signal-to-noise for a +photon that is genuinely spread over the window. + +c3 = sqrt(ClusterSizeX * ClusterSizeY) in the constructor, so it generalises: at +9x9 it is sqrt(81) = 9. + +If someone challenges the independence assumption: it is the pedestal noise that +is being added, which is per-pixel readout noise and is uncorrelated between +pixels to a good approximation. Correlated noise would need covariance terms and +would make c3 larger than sqrt(N). + +The negative-value skip at the top is a fourth branch but not a test in the same +sense -- it drops pixels far BELOW pedestal, which are detector artefacts rather +than photons, and it does not update either. + +What matters for the next slide: Test1 reads the MAX of the window, Test3 reads +the SUM. That is the whole difference in sensitivity.""") + + +# ---------------------------------------------------------------- A7 part 2 +s = new_slide() +annex_chrome(s, 7, "which test causes the CPU/CPU gap · expands slide 30", + "Test3 makes the clusters; Test1 only moves the pedestal", + part=2, nparts=2, title_size=25) +bullets(s, M, 1.76, 11.9, [ + "**push_fast** touches only the pixel's **own** accumulators and never reads " + "the stencil, so the update is **order-independent**: same set of updated " + "pixels, bit-identical pedestal. Only a differing **decision** can diverge.", +], size=10.5) +figure(s, "fig_test3", M + 0.70, 2.34, 10.45) +callout(s, M, 6.22, 11.9, + "Measured two ways. **Instrumented**: of the 19 disagreeing clusters, the " + "**11 that only frozen finds are all Test 3**; the 8 only serial finds are " + "all the local-max gate. **Ablated**: compile Test 3 out and the 11 go to " + "**zero**.", h=0.72, size=10.5) +caption(s, M, 7.06, 11.9, + "3×3 · 10 000 frames · 23 244 605 clusters · per-pixel branch codes " + "diffed frame by frame, then re-run with Test 3 compiled out · " + "python/tests/branch_trace.py, branch_site_dump.py.", size=9) +notes(s, """TWO EXPERIMENTS, INDEPENDENT ROUTES. + +Instrumented (both finders shipped logic, branch codes recorded): 974 pixels out +of 1.6e9 take a different branch. Only some change the cluster set, and those +decompose onto slide 30's 8/11 with no remainder: + + frozen-only 11 = QUIET_UPDATE -> TEST3_STORE (all Test 3) + cpu-only 8 = TEST3_STORE -> TEST3_SKIP (5) (local-max gate) + + TEST1_STORE -> SHADOW (3) + +Ablated (Test 3 compiled out of BOTH finders): + + Test3 ON Test3 OFF + clusters (cpu) 23 244 602 23 241 342 + divergent pixels 974 584 + first divergence frame 4 frame 30 + frozen-only 11 0 + cpu-only 8 4 + +The 11 go to zero exactly. The cpu-only 4 are all TEST1_STORE -> SHADOW, the +local-max gate, which does not need Test 3 -- the count is not preserved because +ablating changes which pixels push, so the pedestal follows a different path and +the downstream ties are a different realisation. + +WHY TEST1 FLIPS MOST AND COSTS NOTHING. A Test1 flip moves a pixel between +QUIET_UPDATE and SHADOW. Neither stores, so no cluster appears or disappears; it +only changes whether that pixel pushed, which feeds forward. + +TEST1 IS NOT MERELY DOWNSTREAM. With Test3 off, the first divergence is still at +frame 30, and nothing diverged before it -- so the pedestals were identical and +that Test1 flip came straight from the within-frame asymmetry. Test1 initiates +independently; it is just ~7x slower to do so (frame 30 vs frame 4) and cannot +create a cluster on its own. + +THE SITE. Frame 203, pixel (125,245). Threshold c3*5*rms = 256.511. Serial sums +256.489 and calls it a pedestal sample; frozen sums 256.581 and stores. The gap +is 0.09 ADU, from four neighbours whose pedestals differ by 0.12 ADU in total. +max is 56.473 in BOTH -- printed because it is the argument: Test1 could not +have caused this. + +READING THE LEFT PANEL. It is the FINISHED frame, not a scan in progress -- the +branch map is read once find_clusters() returns, so every one of the 441 cells +carries a final decision. The arrows are raster ORDER, drawn outside the grid so +they cannot be mistaken for a cursor. + +If asked why a photon looks 3x4 and not 3x3: it does not. The green cells are +the stored clusters and they are single pixels, nine of them in this patch. The +dark region around them is SHADOW, and shadow is not the photon's 3x3 -- it is +every pixel whose OWN 3x3 window contains something above 5 sigma. Note the +shadow pixel need not be bright itself. Three tiers, all visible here: + + 810.3 ADU IS the window max -> stored + 345.0 ADU above the 85.5 bar, not the peak -> shadow + 17.7 ADU nowhere near the bar, but its 3x3 reaches the 345 -> shadow + +Charge shared across two adjacent pixels therefore lights up the union of every +window that can see either one, which here is 3x4. In the whole patch 27 pixels +clear 5 sigma, 9 are local maxima, and 98 end up shadowed. + +The marked pixel is amber with a green ring on purpose: the panel is coloured by +the SERIAL finder, and serial sampled the pedestal there. Only frozen stored. If +it were painted plain green the picture would contradict the sigma lines beside +it. Amber means one thing in BOTH panels -- a pixel that pushed the pedestal -- +which is why the frozen readings on the right are red rather than amber. + +WORTH POINTING AT IF THE ROOM IS ENGINEERS, four rows below the marked pixel. +(129,245) is an isolated shadow cell with pedestal samples on both sides of it. +The cause is the 85.150 ADU pixel at (130,244), one row down and one column +left, which sits in the window of BOTH (129,245) and (129,244). Their window +maxima are IDENTICAL. They take different branches anyway, because the bar is +per-pixel -- the test is m > nSigma * rms[centre], the noise of the pixel being +tested. The branch codes alone bound the two: + + rms(129,245) < 17.030 <= rms(129,244) + +The left neighbour is noisier, so its bar is higher, so the same 85.150 fails to +clear it. And (130,244) is itself only a pedestal sample: 85.2 does not clear its +OWN bar and its window sums to 119.5 against a ~256 Test3 threshold. So a pixel +can silence a neighbour's pedestal update without being bright enough to be +anything itself -- "bright" is not a property of a pixel, it is a relation +between a value and whose noise you measure it against. + +Deliberately NOT marked on the figure. It is a statement about the algorithm, +not about serial-vs-frozen, and a second leader line would compete with the one +that carries the slide's actual argument. Full numbers in docs/deck/QA.md. + +The branch_map property on both finders is diagnostic scaffolding. The ablation +is AARE_TEST3_ENABLED in the two headers, 1 by default.""") + + prs.save(OUT) print(f"saved {OUT} ({len(prs.slides._sldIdLst)} slides)") diff --git a/docs/deck/make_figs.py b/docs/deck/make_figs.py index e62a69d5..37755e2d 100644 --- a/docs/deck/make_figs.py +++ b/docs/deck/make_figs.py @@ -56,6 +56,7 @@ opt7 cuts the kernel 40 % to 23.94 us -- below the D2H bar -- so the f32 floor i D2H, not the kernel. Optimizing the kernel in bottleneck order ended by handing the constraint to the result path, which is what success looks like. """ +import json import re import matplotlib matplotlib.use("Agg") @@ -77,6 +78,10 @@ PALE = "#E7EDF4" # Act II / data 3 / primary text TEXT2 = "#A5B2C4" MUTED = "#6B7A90" # non-data only: grid, axes, annotation GREEN = "#5CC8A0" # rooflines / floors +RED = "#E8695C" # fig_test3 only: the frozen finder, so AMBER can keep its + # one meaning across both panels (a pixel that pushed the + # pedestal). Never colour-alone — the frozen row is always + # labelled and always sits above the serial row. plt.rcParams.update({ "font.family": "DejaVu Sans", "font.size": 9, @@ -1024,9 +1029,13 @@ def fig_correctness(): save(fig, "fig_correctness") +# fig_bottleneck and fig_correctness are placed on no slide and have not been +# since the 22/34 renumber; fig_variance_rewrite joined them when slide 21 moved +# to A5, where the code block says the same thing in less space. The functions +# are kept -- they are the only record of how those figures were built -- but +# they are no longer called, so they stop leaving stale PNGs in docs/figures. for f in (fig_arc, fig_arc_9x9, fig_first_run, fig_overhead, fig_streams, fig_pinning, - fig_graphs, fig_resultpath, fig_f32_kernel, fig_cancellation, - fig_bottleneck, fig_correctness): + fig_graphs, fig_resultpath, fig_f32_kernel, fig_cancellation): f() print("done ->", OUT) @@ -1120,7 +1129,7 @@ def fig_overlap_9x9(): """ fig, ax = plt.subplots(figsize=(11.2, 3.5)) G, H = 30.0, 62.0 - lane_h = 9.0 + lane_h = 8.0 n = 4 def block(x, y, w, col, txt): @@ -1152,7 +1161,10 @@ def fig_overlap_9x9(): for row, (gpu, tag, col) in enumerate([ (gpu2, "2 slots · what ships", AMBER), (gpu3, "3 slots · the natural next guess", MUTED)]): - yG = 49.0 - row * 33.0 + # Row spacing has to clear the row's TALLEST element, which is the tag + # sitting above its GPU lane -- not the lane itself. 37 leaves ~0.45 in + # between one row's tag and the row above's host blocks. + yG = 52.0 - row * 37.0 yH = yG - 12.0 for i in range(n): block(gpu[i], yG, G, ACCENT, f"GPU {i + 1}") @@ -1160,7 +1172,7 @@ def fig_overlap_9x9(): for lbl, y in (("GPU", yG), ("host", yH)): ax.text(-6, y + lane_h / 2, lbl, ha="right", va="center", color=TEXT2, fontsize=10.5) - ax.text(-6, yG + lane_h + 7.0, tag, ha="left", va="bottom", + ax.text(-6, yG + lane_h + 4.5, tag, ha="left", va="bottom", color=col, fontsize=10.5, fontweight="bold") # every gap the GPU sits through, marked where it happens for i in range(1, n): @@ -1173,8 +1185,8 @@ def fig_overlap_9x9(): f"idle {gap:.0f}", ha="center", va="bottom", color=AMBER, fontsize=9.5, fontweight="bold") - ax.plot([finish, finish], [2, 61], color=GREEN, lw=1.6, ls="--", zorder=6) - ax.text(finish + 5, 32, "same finish\nboth ways", ha="left", va="center", + ax.plot([finish, finish], [1, 62], color=GREEN, lw=1.6, ls="--", zorder=6) + ax.text(finish + 5, 31, "same finish\nboth ways", ha="left", va="center", color=GREEN, fontsize=11, fontweight="bold") ax.set_xlim(-32, finish + 62) @@ -1182,6 +1194,166 @@ def fig_overlap_9x9(): ax.axis("off") save(fig, "fig_overlap_9x9") +# --------------------------- 12c. WHICH test carries the serial-vs-frozen gap +def fig_test3(): + """Measured proof that Test3 is the channel, and Test1 is not. + + The two panels are deliberately on DIFFERENT clocks, and each says so: + + Left is the 21x21 neighbourhood of the site AFTER the frame is finished -- + the branch map is read once find_clusters() returns, so every cell carries a + final decision. An earlier version drew a "the scan is here" cursor over it, + which was a contradiction: the map has no undecided cells to point at. The + arrows now run uniformly across every row and mean raster ORDER, not + progress. + + Right is the instant the centre pixel was tested, which is the only moment at + which the two models can be said to disagree. Four of its neighbours are in + the raster's past and may already carry this frame's push; four are in its + future and cannot. Exactly those four differ, and the centre does not. + + Three fills, because the finder has three outcomes and merging any two of + them invites the question "why is that photon 3x4 pixels?": + + stored the window max, and it clears 5 sigma (~1.5 %) + shadow the window max clears 5 sigma, but this (~18 %) + pixel is not it -- and note the pixel + itself need NOT be bright: a 17.7 ADU + pixel is shadow if its 3x3 reaches the + 345 ADU one next door + sample nothing in the window clears; push pedestal (~80 %) + + So a shadow region is not a photon's 3x3. It is the union of every window + that can SEE something above 5 sigma, which is why sharing charge across two + adjacent pixels (810.3 and 345.0 here, against a bar of 85.5) lights up 3x4. + + The site itself is marked amber-filled with a green ring, because the panel + is coloured by the SERIAL finder and serial pushed the pedestal there. Only + frozen stored. That disagreement is the whole slide. + + The punchline is in the numbers, not the picture: `max` is IDENTICAL in the + two models (56.473), so Test1 provably did not move. Only the SUM crossed. + """ + site = json.loads((Path(__file__).resolve().parent / "branch_site.json").read_text()) + vf = np.array(site["val_frz"]); vc = np.array(site["val_cpu"]) + scanned = np.array(site["scanned"], dtype=bool) + thr = site["thr_test3_frz"] + pat = site["patch"] + bc = np.array(pat["branch_cpu"]); R = pat["r"] + + fig, (ax, bx) = plt.subplots(1, 2, figsize=(12.4, 4.25), + gridspec_kw=dict(width_ratios=[1.28, 1.0])) + # An equal-aspect axes shrinks its BOX to the drawing and then centres it, + # which parked both grids in the middle of their slots with dead space on + # either side. Anchor west so each grid sits over the legend that decodes it. + ax.set_anchor("W"); bx.set_anchor("W") + + # ---- left: the finished frame, 21x21 around the site ------------------- + # Colour by what the SERIAL finder decided: the pedestal-sample cells are + # exactly the ones a later stencil can read differently from the frozen + # model, which is the mechanism this slide is about. Shadow gets its own + # fill -- welding it to `stored` is what made a photon look 3x4 wide. + SHADOW = "#33455E" + FILL = {4: AMBER, 1: SHADOW, 2: GREEN, 3: GREEN, 6: SHADOW, + 0: SHADOW, 5: PANEL} + n = 2 * R + 1 + for r in range(n): + for c in range(n): + ax.add_patch(Rectangle((c, n - 1 - r), 1, 1, + facecolor=FILL.get(int(bc[r, c]), PANEL), + edgecolor=BG, linewidth=0.5, zorder=2)) + # Raster ORDER, not raster progress, and drawn OUTSIDE the data: arrows laid + # over the cells vanished against the amber and re-introduced the "we are + # here" reading. Two margin arrows say left-to-right, then top-to-bottom. + ax.annotate("", xy=(n, n + 0.55), xytext=(0.0, n + 0.55), + arrowprops=dict(arrowstyle="-|>", color=MUTED, lw=1.2)) + ax.annotate("", xy=(-0.85, 0.0), xytext=(-0.85, n), + arrowprops=dict(arrowstyle="-|>", color=MUTED, lw=1.2)) + ax.text(n / 2, n + 0.85, "raster order", ha="center", va="bottom", + color=MUTED, fontsize=10.5) + # the window Test3 summed, and inside it the one pixel the models disagree on + ax.add_patch(Rectangle((R - 1, n - R - 2), 3, 3, facecolor="none", + edgecolor=PALE, linewidth=1.4, ls=(0, (3, 2)), + zorder=6)) + ax.add_patch(Rectangle((R, n - R - 1), 1, 1, facecolor="none", + edgecolor=GREEN, linewidth=2.4, zorder=7)) + ax.annotate("the pixel they\ndisagree on", xy=(R + 1.6, n - R - 0.5), + xytext=(n + 1.4, n - R - 0.5), ha="left", va="center", + color=PALE, fontsize=10.5, + arrowprops=dict(arrowstyle="-", color=PALE, lw=1.0, + shrinkA=2, shrinkB=2)) + # Headroom for the title ABOVE the raster-order label, not on top of it. + ax.set_xlim(-1.6, n + 8.8); ax.set_ylim(-0.4, n + 3.6) + ax.set_aspect("equal"); ax.axis("off") + ax.text(n / 2, n + 3.5, f"the finished frame · 21 × 21 around " + f"({site['iy']}, {site['ix']})", + ha="center", va="top", color=TEXT2, fontsize=10.5) + + # ---- right: the 3x3, with each finder's reading named ------------------- + for r in range(3): + for c in range(3): + past = scanned[r, c] + bx.add_patch(Rectangle((c, 2 - r), 1, 1, + facecolor="#1B2534" if past else PANEL, + edgecolor=AMBER if past else BG, + linewidth=2.2 if past else 1.6, zorder=2)) + if past: + bx.text(c + 0.5, 2 - r + 0.66, f"{vf[r, c]:.3f}", ha="center", + va="center", color=RED, fontsize=11, + fontweight="bold", zorder=3) + bx.text(c + 0.5, 2 - r + 0.32, f"{vc[r, c]:.3f}", ha="center", + va="center", color=ACCENT, fontsize=11, + fontweight="bold", zorder=3) + else: + bx.text(c + 0.5, 2 - r + 0.50, f"{vf[r, c]:.3f}", ha="center", + va="center", color=PALE, fontsize=11, + fontweight="bold", zorder=3) + bx.add_patch(Rectangle((1, 1), 1, 1, facecolor="none", edgecolor=GREEN, + linewidth=2.6, zorder=4)) + bx.set_xlim(-0.06, 3.06); bx.set_ylim(-0.06, 3.66) + bx.set_aspect("equal"); bx.axis("off") + bx.text(1.5, 3.60, f"the moment ({site['iy']}, {site['ix']}) was tested · " + f"only the 4 already-scanned neighbours differ", + ha="center", va="top", color=TEXT2, fontsize=10.5) + + # The verdict goes in figure coords: inside the axes it would be laid out + # against an equal-aspect box and squeeze the grid into a column. Three + # fills, three legend rows -- a swatch each, because the shadow fill is far + # too dark to identify from coloured text. + def key(y, col, txt, edge=None): + fig.add_artist(Rectangle((0.020, y - 0.004), 0.017, 0.042, + facecolor=col, edgecolor=edge or BG, + linewidth=2.0 if edge else 0.8, + transform=fig.transFigure)) + fig.text(0.046, y + 0.017, txt, color=TEXT2, fontsize=10.5, + va="center") + + key(0.245, GREEN, "stored: this pixel IS the window max, and it clears 5σ") + key(0.170, SHADOW, "shadow: the window max clears 5σ, but this pixel is not it") + key(0.095, AMBER, "pedestal sample: nothing in the window clears 5σ") + key(0.020, AMBER, "the disputed pixel — serial sampled here, frozen stored", + edge=GREEN) + + # No hand-placed colour key: the two sigma rows below are already + # colour-coded, so the cells decode from them. + # Keep this line no longer than the sigma rows below it: bbox_inches="tight" + # widens the canvas to the widest string, which shrinks every other one. + fig.text(0.545, 0.250, "frozen above serial · amber ring = pushed pedestal", + color=TEXT2, fontsize=10.5) + fig.text(0.545, 0.175, f"serial Σ = {site['total_cpu']:.3f} < " + f"{thr:.3f} → pedestal sample", + color=ACCENT, fontsize=10.5, fontweight="bold") + fig.text(0.545, 0.100, f"frozen Σ = {site['total_frz']:.3f} > " + f"{thr:.3f} → CLUSTER", + color=RED, fontsize=10.5, fontweight="bold") + fig.text(0.545, 0.025, f"max = {site['max_frz']:.3f} in both → " + f"Test1 never moved", + color=GREEN, fontsize=10.5, fontweight="bold") + + fig.subplots_adjust(left=0.015, right=0.985, top=0.97, bottom=0.31, + wspace=0.06) + save(fig, "fig_test3") + # ------------------------------------- 13. pedestal update timing, three ways def fig_pedtiming(): """Why ClusterFinderFrozen exists: the one variable it holds still. @@ -1256,6 +1428,7 @@ def fig_pedtiming(): fig_overlap() fig_overlap_9x9() +fig_test3() fig_pedtiming() @@ -1616,7 +1789,7 @@ def fig_variance_rewrite(): save(fig, "fig_variance_rewrite") -fig_variance_rewrite() +# fig_variance_rewrite() # unplaced since slide 21 moved to A5; see above # ---------------------------- 16. the measurement convention: s1, s4 and the floor diff --git a/docs/figures/fig_bottleneck.png b/docs/figures/fig_bottleneck.png deleted file mode 100644 index 0470265f..00000000 Binary files a/docs/figures/fig_bottleneck.png and /dev/null differ diff --git a/docs/figures/fig_correctness.png b/docs/figures/fig_correctness.png deleted file mode 100644 index 0e86a1cc..00000000 Binary files a/docs/figures/fig_correctness.png and /dev/null differ diff --git a/docs/figures/fig_overlap_9x9.png b/docs/figures/fig_overlap_9x9.png index 5b11667d..10e19b3c 100644 Binary files a/docs/figures/fig_overlap_9x9.png and b/docs/figures/fig_overlap_9x9.png differ diff --git a/docs/figures/fig_test3.png b/docs/figures/fig_test3.png new file mode 100644 index 00000000..6478a1eb Binary files /dev/null and b/docs/figures/fig_test3.png differ diff --git a/docs/figures/fig_variance_rewrite.png b/docs/figures/fig_variance_rewrite.png deleted file mode 100644 index 7f9ef1a7..00000000 Binary files a/docs/figures/fig_variance_rewrite.png and /dev/null differ diff --git a/include/aare/ClusterFinder.hpp b/include/aare/ClusterFinder.hpp index 83b5c780..d51ce063 100644 --- a/include/aare/ClusterFinder.hpp +++ b/include/aare/ClusterFinder.hpp @@ -9,6 +9,25 @@ #include "aare/defs.hpp" #include +// --- ABLATION SWITCH (diagnostic, removable) ------------------------------- +// Set to 0 to compile out Test3 (the total-significance test) while leaving +// every other decision untouched. Used to confirm, by an independent route from +// the branch-map trace, that Test3 is the channel through which pedestal update +// TIMING reaches the cluster set. Kept as an expression rather than #if so that +// `total` stays used and the two arms compile identically otherwise. +// --- AARE_BRANCH_TRACE (diagnostic, off by default) ------------------------- +// 1 makes find_clusters() record which branch every pixel took, for the +// serial-vs-frozen study in annex A7 of the deck. Left at 0 the writes fold +// away at compile time, so the shipped path -- including the CPU baseline whose +// throughput the deck quotes -- is byte-for-byte what it was without this. +#ifndef AARE_BRANCH_TRACE +#define AARE_BRANCH_TRACE 0 +#endif + +#ifndef AARE_TEST3_ENABLED +#define AARE_TEST3_ENABLED 1 +#endif + namespace aare { template m_pedestal; ClusterVector m_clusters; + // --- AARE_BRANCH_TRACE (diagnostic, removable) --------------------------- + // Per-pixel record of WHICH branch each pixel took this frame. Written to a + // side buffer only; no decision reads it, so behaviour is unchanged. + // 0 NEG value < -nSigma*rms (no update) + // 1 SHADOW Test1 pass, value < max (no update) + // 2 TEST1_STORE Test1 pass, value == max -> cluster + // 3 TEST3_STORE Test1 fail, Test3 pass, stored + // 6 TEST3_SKIP Test1 fail, Test3 pass, not stored (value < max) + // 4 QUIET both fail -> pedestal update + // 5 UNTOUCHED (frame not yet scanned here) + std::vector m_branch; + static const uint8_t ClusterSizeX = ClusterType::cluster_size_x; static const uint8_t ClusterSizeY = ClusterType::cluster_size_y; using CT = typename ClusterType::value_type; @@ -48,6 +79,7 @@ class ClusterFinder { c2(sqrt((ClusterSizeY + 1) / 2 * (ClusterSizeX + 1) / 2)), c3(sqrt(ClusterSizeX * ClusterSizeY)), m_pedestal(image_size[0], image_size[1]), m_clusters(capacity) { + m_branch.assign(image_size[0] * image_size[1], 5); LOG(logDEBUG) << "ClusterFinder: " << "image_size: " << image_size[0] << "x" << image_size[1] << ", nSigma: " << nSigma << ", capacity: " << capacity; @@ -65,6 +97,13 @@ class ClusterFinder { NDArray noise() { return m_pedestal.std(); } void clear_pedestal() { m_pedestal.clear(); } + /// AARE_BRANCH_TRACE: last frame's per-pixel branch codes. + NDArray branch_map() const { + NDArray out({m_image_size[0], m_image_size[1]}); + std::copy(m_branch.begin(), m_branch.end(), out.begin()); + return out; + } + /** * @brief Move the clusters from the ClusterVector in the ClusterFinder to a * new ClusterVector and return it. @@ -94,6 +133,9 @@ class ClusterFinder { int has_center_pixel_y = ClusterSizeY % 2; m_clusters.set_frame_number(frame_number); + if (AARE_BRANCH_TRACE) + std::fill(m_branch.begin(), m_branch.end(), uint8_t{5}); + const int _bw = frame.shape(1); for (int iy = 0; iy < frame.shape(0); iy++) { for (int ix = 0; ix < frame.shape(1); ix++) { @@ -104,9 +146,11 @@ class ClusterFinder { PEDESTAL_TYPE rms = m_pedestal.std(iy, ix); PEDESTAL_TYPE value = (frame(iy, ix) - m_pedestal.mean(iy, ix)); - if (value < -m_nSigma * rms) + if (value < -m_nSigma * rms) { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 0; continue; // NEGATIVE_PEDESTAL go to next pixel // TODO! No pedestal update??? + } for (int ir = -dy; ir < dy + has_center_pixel_y; ir++) { for (int ic = -dx; ic < dx + has_center_pixel_x; ic++) { @@ -123,12 +167,16 @@ class ClusterFinder { } if ((max > m_nSigma * rms)) { - if (value < max) + if (value < max) { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 1; continue; // Not max go to the next pixel // but also no pedestal update - } else if (total > c3 * m_nSigma * rms) { - // pass + } + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 2; + } else if (AARE_TEST3_ENABLED && total > c3 * m_nSigma * rms) { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = (value == max) ? 3 : 6; } else { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 4; // m_pedestal.push(iy, ix, frame(iy, ix)); // Safe option m_pedestal.push_fast( iy, ix, diff --git a/include/aare/ClusterFinderFrozen.hpp b/include/aare/ClusterFinderFrozen.hpp index e9487b3a..e9afbb08 100644 --- a/include/aare/ClusterFinderFrozen.hpp +++ b/include/aare/ClusterFinderFrozen.hpp @@ -12,6 +12,25 @@ #include #include +// --- ABLATION SWITCH (diagnostic, removable) ------------------------------- +// Set to 0 to compile out Test3 (the total-significance test) while leaving +// every other decision untouched. Used to confirm, by an independent route from +// the branch-map trace, that Test3 is the channel through which pedestal update +// TIMING reaches the cluster set. Kept as an expression rather than #if so that +// `total` stays used and the two arms compile identically otherwise. +// --- AARE_BRANCH_TRACE (diagnostic, off by default) ------------------------- +// 1 makes find_clusters() record which branch every pixel took, for the +// serial-vs-frozen study in annex A7 of the deck. Left at 0 the writes fold +// away at compile time, so the shipped path -- including the CPU baseline whose +// throughput the deck quotes -- is byte-for-byte what it was without this. +#ifndef AARE_BRANCH_TRACE +#define AARE_BRANCH_TRACE 0 +#endif + +#ifndef AARE_TEST3_ENABLED +#define AARE_TEST3_ENABLED 1 +#endif + namespace aare { /** @@ -48,6 +67,18 @@ class ClusterFinderFrozen { Pedestal m_pedestal; ClusterVector m_clusters; + // --- AARE_BRANCH_TRACE (diagnostic, removable) --------------------------- + // Per-pixel record of WHICH branch each pixel took this frame. Written to a + // side buffer only; no decision reads it, so behaviour is unchanged. + // 0 NEG value < -nSigma*rms (no update) + // 1 SHADOW Test1 pass, value < max (no update) + // 2 TEST1_STORE Test1 pass, value == max -> cluster + // 3 TEST3_STORE Test1 fail, Test3 pass, stored + // 6 TEST3_SKIP Test1 fail, Test3 pass, not stored (value < max) + // 4 QUIET both fail -> pedestal update + // 5 UNTOUCHED (frame not yet scanned here) + std::vector m_branch; + static const uint8_t ClusterSizeX = ClusterType::cluster_size_x; static const uint8_t ClusterSizeY = ClusterType::cluster_size_y; using CT = typename ClusterType::value_type; @@ -59,6 +90,7 @@ class ClusterFinderFrozen { c2(sqrt((ClusterSizeY + 1) / 2 * (ClusterSizeX + 1) / 2)), c3(sqrt(ClusterSizeX * ClusterSizeY)), m_pedestal(image_size[0], image_size[1]), m_clusters(capacity) { + m_branch.assign(image_size[0] * image_size[1], 5); LOG(logDEBUG) << "ClusterFinderFrozen: " << "image_size: " << image_size[0] << "x" << image_size[1] << ", nSigma: " << nSigma << ", capacity: " << capacity; @@ -75,6 +107,13 @@ class ClusterFinderFrozen { NDArray noise() { return m_pedestal.std(); } void clear_pedestal() { m_pedestal.clear(); } + /// AARE_BRANCH_TRACE: last frame's per-pixel branch codes. + NDArray branch_map() const { + NDArray out({m_image_size[0], m_image_size[1]}); + std::copy(m_branch.begin(), m_branch.end(), out.begin()); + return out; + } + ClusterVector steal_clusters(bool realloc_same_capacity = false) { ClusterVector tmp = std::move(m_clusters); @@ -92,6 +131,9 @@ class ClusterFinderFrozen { int has_center_pixel_y = ClusterSizeY % 2; m_clusters.set_frame_number(frame_number); + if (AARE_BRANCH_TRACE) + std::fill(m_branch.begin(), m_branch.end(), uint8_t{5}); + const int _bw = frame.shape(1); // FROZEN pedestal snapshot. Every decision this frame reads from these // copies, so an intra-frame push cannot influence a later pixel. This @@ -113,8 +155,10 @@ class ClusterFinderFrozen { PEDESTAL_TYPE rms = ped_std(iy, ix); PEDESTAL_TYPE value = (frame(iy, ix) - ped_mean(iy, ix)); - if (value < -m_nSigma * rms) + if (value < -m_nSigma * rms) { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 0; continue; // NEGATIVE_PEDESTAL, no pedestal update + } for (int ir = -dy; ir < dy + has_center_pixel_y; ir++) { for (int ic = -dx; ic < dx + has_center_pixel_x; ic++) { @@ -129,11 +173,15 @@ class ClusterFinderFrozen { } if ((max > m_nSigma * rms)) { - if (value < max) + if (value < max) { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 1; continue; // Not max, no pedestal update - } else if (total > c3 * m_nSigma * rms) { - // pass + } + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 2; + } else if (AARE_TEST3_ENABLED && total > c3 * m_nSigma * rms) { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = (value == max) ? 3 : 6; } else { + if (AARE_BRANCH_TRACE) m_branch[iy * _bw + ix] = 4; // Defer the pedestal update to end of frame (see below). deferred.emplace_back(iy, ix); continue; diff --git a/python/src/bind_ClusterFinder.hpp b/python/src/bind_ClusterFinder.hpp index da479dc5..bb91f29a 100644 --- a/python/src/bind_ClusterFinder.hpp +++ b/python/src/bind_ClusterFinder.hpp @@ -62,6 +62,14 @@ void define_ClusterFinder(py::module &m, const std::string &typestr) { *arr = self.noise(); return return_image_data(arr); }) + // AARE_BRANCH_TRACE (diagnostic, removable) + .def_property_readonly( + "branch_map", + [](ClusterFinder &self) { + auto arr = new NDArray{}; + *arr = self.branch_map(); + return return_image_data(arr); + }) .def( "steal_clusters", [](ClusterFinder &self, diff --git a/python/src/bind_ClusterFinderFrozen.hpp b/python/src/bind_ClusterFinderFrozen.hpp index 1f214e4d..da3246e6 100644 --- a/python/src/bind_ClusterFinderFrozen.hpp +++ b/python/src/bind_ClusterFinderFrozen.hpp @@ -58,6 +58,14 @@ void define_ClusterFinderFrozen(py::module &m, const std::string &typestr) { *arr = self.noise(); return return_image_data(arr); }) + // AARE_BRANCH_TRACE (diagnostic, removable) + .def_property_readonly( + "branch_map", + [](ClusterFinderFrozen &self) { + auto arr = new NDArray{}; + *arr = self.branch_map(); + return return_image_data(arr); + }) .def( "steal_clusters", [](ClusterFinderFrozen &self, diff --git a/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb b/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb index db01cf02..861a5e30 100644 --- a/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb +++ b/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb @@ -96,7 +96,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "pedestal train: 0.78s\n", + "pedestal train: 0.79s\n", "data: (10000, 400, 400) uint16\n" ] } @@ -128,10 +128,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "compare", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scanned 10000 frames\n", + "\n", + "Total clusters per finder:\n", + " cpu 23,244,602\n", + " frozen 23,244,605\n", + " cuda 23,244,611\n", + "\n", + "Pairwise exact mismatches (tol=0):\n", + " pair A-only B-only total\n", + " cpu vs frozen 8 11 19 (0.0001%)\n", + " cpu vs cuda 8 17 25 (0.0001%)\n", + " frozen vs cuda 0 6 6 (0.0000%)\n" + ] + } + ], "source": [ "SCAN = 10000 # frames sampled across `data` (set to len(data) for the full block)\n", "\n", @@ -166,10 +185,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "f057e296", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = plot_spectra(hists, totals,\n", " title=f'Cluster energy spectra — cluster_size={cluster_size}, n_streams={N_STREAMS}')" @@ -188,10 +218,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "resid", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "frozen-only: 0 cuda-only: 6 frames shown: 6\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "cf_frozen2 = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n", "cf_cuda2 = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n", @@ -220,12 +268,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "c27d894d-64b2-45b2-aaa8-bfddc754b3f9", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "frame 147 centre (x=202, y=8) accepted only by cuda\n", + "raw window (ADU):\n", + "[[4646 5282 4703]\n", + " [4857 5318 4950]\n", + " [4763 4640 4858]]\n", + "\n", + "--- frozen ---\n", + " subtracted window:\n", + " [[ 45.3 638.4 -12.1]\n", + " [ 43.7 638.4 -7.5]\n", + " [ 1.1 70.7 136.4]]\n", + " centre value = 638.38 (local max? False)\n", + " max = 638.38 total = 1554.37\n", + " rms(centre) = 19.109\n", + " Test1: max > 5*rms = 95.54 -> True\n", + " Test3: total > 3*5*rms = 286.63 -> True\n", + " ACCEPT = False\n", + "\n", + "--- cuda ---\n", + " subtracted window:\n", + " [[ 45.3 638.4 -12.1]\n", + " [ 43.7 638.4 -7.5]\n", + " [ 1.1 70.7 136.4]]\n", + " centre value = 638.38 (local max? True)\n", + " max = 638.38 total = 1554.37\n", + " rms(centre) = 19.109\n", + " Test1: max > 5*rms = 95.54 -> True\n", + " Test3: total > 3*5*rms = 286.63 -> True\n", + " ACCEPT = True\n", + "\n", + "RESULT: frozen = reject , cuda = ACCEPT\n", + "pedestal mean gap @centre = 0.0000 ADU; rms gap = 0.0000\n" + ] + } + ], "source": [ "# Dissect the surviving frozen-vs-cuda residual.\n", "# Recomputes Test1/Test3 under each finder's decision-time snapshot pedestal, so the\n", diff --git a/python/tests/branch_site.json b/python/tests/branch_site.json new file mode 100644 index 00000000..16625a91 --- /dev/null +++ b/python/tests/branch_site.json @@ -0,0 +1,1583 @@ +{ + "frame": 203, + "iy": 125, + "ix": 245, + "n_sigma": 5, + "c3": 3.0, + "raw": [ + [ + 4460.0, + 4461.0, + 4376.0 + ], + [ + 4461.0, + 4582.0, + 4392.0 + ], + [ + 4463.0, + 4541.0, + 4451.0 + ] + ], + "ped_cpu": [ + [ + 4428.362910585158, + 4475.405456375104, + 4342.270466162139 + ], + [ + 4419.362167080695, + 4525.527419531644, + 4361.992883395069 + ], + [ + 4447.785996280896, + 4500.783468558215, + 4429.020731723249 + ] + ], + "ped_frz": [ + [ + 4428.331241826984, + 4475.419876251356, + 4342.236702865004 + ], + [ + 4419.320487568263, + 4525.527419531644, + 4361.992883395069 + ], + [ + 4447.785996280896, + 4500.783468558215, + 4429.020731723249 + ] + ], + "val_cpu": [ + [ + 31.637089414842194, + -14.405456375104222, + 33.7295338378608 + ], + [ + 41.637832919304856, + 56.47258046835577, + 30.00711660493107 + ], + [ + 15.214003719103857, + 40.216531441785264, + 21.9792682767511 + ] + ], + "val_frz": [ + [ + 31.668758173015704, + -14.419876251356072, + 33.76329713499581 + ], + [ + 41.67951243173684, + 56.47258046835577, + 30.00711660493107 + ], + [ + 15.214003719103857, + 40.216531441785264, + 21.9792682767511 + ] + ], + "scanned": [ + [ + true, + true, + true + ], + [ + true, + false, + false + ], + [ + false, + false, + false + ] + ], + "rms_cpu": 17.100731620366265, + "rms_frz": 17.100731620366265, + "total_cpu": 256.4885003078307, + "total_frz": 256.58119199931934, + "max_cpu": 56.47258046835577, + "max_frz": 56.47258046835577, + "value_cpu": 56.47258046835577, + "value_frz": 56.47258046835577, + "thr_test1_cpu": 85.50365810183132, + "thr_test1_frz": 85.50365810183132, + "thr_test3_cpu": 256.51097430549396, + "thr_test3_frz": 256.51097430549396, + "branch_cpu": 4, + "branch_frz": 3, + "patch": { + "r": 10, + "y0": 115, + "x0": 235, + "val": [ + [ + 319.79361653683463, + 7.774178833213227, + 15.657109931747982, + 9.174055354302254, + 12.276449703674189, + -12.463942541519828, + 37.63465287577674, + 12.891218618950006, + -0.6692921831208878, + 13.590359436163453, + -11.504722827477963, + 36.80476959438329, + 1.3513369731581406, + 33.940059758389, + -8.654314739212168, + -32.84133563287014, + 1.244335541991859, + 3.0134293898399847, + 828.9528213791446, + 26.38650273452913, + 4.926644116099851 + ], + [ + 286.99671926258816, + -9.955745757140903, + 20.78026637797302, + 19.14097424627471, + 6.330712167142337, + 8.660815187455228, + 16.78703963863063, + -3.856478511993373, + -16.261114832464045, + 0.4438977386826082, + -25.607921949994306, + 2.162980328204867, + -8.398907692566354, + -6.234963659084315, + 2.089441144072225, + -31.841624473179763, + -5.622300276005262, + -15.018593617697661, + 318.9585926769669, + 6.592424587644018, + 17.65649237184607 + ], + [ + -1.5170625644404936, + -10.86117794978054, + 16.925466295977458, + -5.163288104528874, + 8.78874747808186, + -5.100122602585543, + 36.55980625217944, + 14.65131240516348, + 8.732674004592809, + 12.021483639145117, + -0.11889365719525813, + 9.476589358488127, + -3.7736367424085984, + 7.01244506981584, + 0.16041935831617593, + -12.419713404055074, + -17.61450165153383, + 638.2514989430902, + 146.05019890732274, + -5.8633962449112005, + 15.948595498503892 + ], + [ + -1.434320271294382, + -10.06424494949897, + 6.131203107410329, + 23.830147711223617, + 30.164660191258918, + 17.454068079669014, + 31.370836934600447, + -9.428608486151461, + 6.575075104299685, + 17.08822395451898, + 21.183093657754398, + -24.571782731239182, + -0.5502814368328472, + -9.915292648913237, + -7.263933309033746, + -36.9143556272511, + -9.544487457404102, + 390.6946885624038, + 98.28513847149134, + 0.3138302470188137, + -6.551237125815533 + ], + [ + 51.81455326406012, + -0.6830816765086638, + -27.058965793038624, + -6.707232443744942, + 26.419967468158575, + 17.07463134063346, + 24.750974880144895, + 7.75193201476759, + 0.6044368569191647, + 44.870659695838185, + -2.1653321536450676, + 11.7058274437195, + 10.631895924631863, + 15.379928493321131, + 26.63754895022703, + -10.195445169884806, + -18.447250495589287, + 25.61743067986754, + -20.158074939408834, + 52.99675476926586, + 43.17806425832168 + ], + [ + 18.043383844579694, + -6.454234002985686, + 39.069824126944695, + 5.706140554391823, + 9.777155936206327, + 14.996536533246399, + 27.64586265617345, + 21.280474939007945, + 3.3901485804608456, + 43.10070722459659, + 4.530369289124792, + -2.0146474720222614, + -25.504764814074406, + -13.297096269721806, + 20.02889844364927, + -4.469667542035495, + -5.733110184547513, + -4.206362023939619, + 8.947560731000522, + 44.179298530726555, + -14.89734812203642 + ], + [ + 45.99697170367108, + 7.840150171797177, + 42.71850282719515, + -2.512526444635114, + -16.144289259599645, + 2.336004534442509, + 13.892849791952358, + 11.205302915454013, + -7.219841381076549, + 22.517637975568505, + -24.644613764501628, + -12.064288468991435, + -1.311484895427384, + -18.33216717231153, + 47.140350925257735, + -7.565209282456635, + -14.903834318845838, + 184.63993180580837, + 886.7120386857559, + 13.527493133176904, + 11.518033033263237 + ], + [ + -14.747604088960543, + -17.02059963868396, + 25.816196784475324, + 1.3534092391528247, + 46.18679525112384, + 21.94076589898941, + 14.580873238611275, + -15.902570202202696, + -9.712955699430495, + 11.978697518714398, + 3.540071538312077, + -14.151137929328797, + -2.811796207752195, + 19.202647841704675, + 6.304235626644186, + 11.841501978536144, + -0.3681926482322524, + 60.91452704657058, + 126.89795976820278, + 12.210518952912025, + 23.13126687685417 + ], + [ + 4.668084751223432, + 11.281120726108384, + -6.294141984980342, + 15.380302541540914, + 39.550713154301775, + -31.119537792430492, + 28.560463229339803, + -14.415852678464034, + 2.7762647661584197, + 39.32078875338357, + 24.370928350791473, + 31.384430668262212, + -5.874197659532911, + 11.070733068268964, + -37.080259201360604, + 5.310787288377469, + 3.9066794886248317, + -5.2995618549330175, + 23.87522507308313, + -5.407816470346916, + -17.50124845789469 + ], + [ + 2.7467243982946457, + 11.994116522115291, + 8.361386410753767, + 3.3895092924731216, + 32.88573248035664, + -10.461339400109864, + 28.7286020680167, + 4.968074042417356, + 21.482269484829885, + 31.668758173015704, + -14.419876251356072, + 33.76329713499581, + -35.92942445310564, + -5.272115586394648, + -2.0586046080015876, + -18.274619090274427, + -9.772224943463698, + -36.210441308268855, + -7.883454863083898, + 55.080537173274934, + 0.15437704166470212 + ], + [ + 26.463246277568032, + -1.6032929061111645, + 27.125389347070268, + -7.822603950976372, + 13.72429721129447, + 11.292470922578104, + 3.2587369746624972, + 3.873700631994325, + -10.312793600873192, + 41.67951243173684, + 56.47258046835577, + 30.00711660493107, + 15.236609571260487, + -3.983117654985108, + -0.6030881662354659, + 1.3336933305163257, + 10.22107821719419, + -6.874491356146791, + -21.6066593712967, + -20.523282511339858, + 37.28802709165302 + ], + [ + -32.411747361837115, + -19.35587970421784, + -9.201511426624165, + 46.72181206995083, + 14.131257476010433, + -43.03000897108359, + 28.61445126113631, + -12.37872350372254, + 45.10884702344629, + 15.214003719103857, + 40.216531441785264, + 21.9792682767511, + -13.619689446909433, + 4.056459092669684, + -6.8607252041711035, + 2.7100500786200428, + -17.679653712998515, + 31.904076496608468, + 29.77461544137259, + -14.813640928880886, + 7.304511723644282 + ], + [ + 21.584487595784594, + 1.5203005945786572, + 7.949840246319582, + 7.493931802386214, + 25.85140967231746, + 0.19624434439720062, + 17.705960005957422, + 345.0084227579973, + 810.2806037007795, + 25.77760003610365, + 18.870223682817596, + 8.94371510242945, + -29.56505153699709, + -38.805310699051915, + 22.733351394739657, + -8.2978579831979, + -30.679393232624534, + 14.74095696798031, + 4.641040075322053, + 20.97823546332802, + -4.172786115992494 + ], + [ + -15.219270547723681, + -0.38593709860197123, + 11.280103827557468, + 8.949688204666927, + -38.51000952878712, + -36.94552681470668, + 26.868389984104397, + 29.43047764087987, + 66.42587235452902, + 40.49869673059766, + -1.549700761483109, + -3.9900346103568154, + 16.95829946376398, + -9.839609435131024, + 848.0411337916285, + 167.49535490230937, + 18.269174373586793, + 16.030968485139056, + -29.38153347061325, + 15.066168430562357, + 8.36609377185141 + ], + [ + 1.6898792707306711, + 18.67235945532684, + -12.126363710017358, + 2.086196277597992, + -18.521382163027738, + 22.716957189085406, + 8.357586677067957, + -9.775560224639776, + -14.228696916474291, + 31.514789614532674, + 7.247424140096882, + -18.467596078672614, + -6.35522545294225, + -13.895267157300623, + 71.43190026329648, + 9.604846942467702, + -32.96890946868007, + -25.665985559509863, + -5.191936788602106, + -6.495023736179064, + 112.9756965686338 + ], + [ + 559.8558044451165, + 480.887446049941, + -6.374121077910786, + 19.87981189794573, + 32.32388118443396, + -21.888185908974265, + 222.60599098455532, + 606.4008093866742, + -27.123557624171553, + 85.1502926677058, + 2.5931495912536775, + 11.248678806696262, + -19.115029127970047, + 16.318687726082317, + -37.15840182215561, + -12.42436810914296, + 3.0438715686941578, + 41.70788662261202, + 33.02656838923485, + -3.1301139395554856, + 95.7752125042798 + ], + [ + 66.99120260678956, + 94.42071279494576, + 7.083683841535276, + -5.337193029956325, + 44.04980803214403, + -23.626089469749786, + 99.37327409799218, + 278.57042935653226, + -9.153894102312734, + 33.47546084150872, + 9.999644755749614, + 19.382134216977647, + 35.25555381875711, + 7.595883102892913, + 9.979060322792066, + 2.224981530038349, + -29.452826725451814, + 12.686056028612256, + 27.203585286620182, + -4.611486457078172, + 19.165633730728587 + ], + [ + 28.034218216035697, + 17.97322318746683, + 2.298619708441038, + 32.178437120108356, + -0.5495541317322932, + 2.976801708245148, + -7.988442881309311, + 8.71350090962369, + 9.566408678600965, + 21.16593814252974, + 9.825751863664664, + 15.325506233446504, + -2.8671801538048385, + 1.0796584265171987, + 3.3854864314453152, + 6.382522486527705, + 12.166892715010363, + 16.312653949617925, + 14.69602848363229, + 45.20404710140156, + 30.275933719684872 + ], + [ + -7.491320118840122, + 23.56195130413562, + 17.693997785801002, + -5.516188300308386, + 26.695319590981853, + -2.75473458489887, + 15.69121382558842, + 34.85033916128123, + -7.828561995695964, + 19.562939990487394, + 27.499708011837356, + 5.957857620785944, + -32.67984203377, + 10.506065486493753, + 14.473719456928848, + -22.047067074514416, + 0.9573057043289737, + -10.953291853996234, + -13.659236730167322, + 12.540806295478433, + 3.5030120684878057 + ], + [ + 32.71361042753597, + 2.1209678939167134, + 7.820462613973177, + 7.310262076856816, + 72.22327328566917, + 249.7592124853054, + 2.5453734498523772, + -9.597577117817309, + -20.406731883981593, + 21.145533411644465, + 8.86830177234151, + 22.966156676387072, + 7.340151660164338, + 0.31179150926800503, + -8.704699551054546, + 0.9947463451471776, + 26.202031495074152, + 31.0248203741412, + -19.244984531565024, + 2.527415496660069, + 2.056726665910901 + ], + [ + 17.164465151496188, + -18.38237829343325, + 6.815282776608001, + -2.327084038826797, + 96.65006048993564, + 717.05123660357, + 15.34398992612114, + 4.819378996417072, + 13.0279909955525, + 15.121650674516786, + -2.999588907459838, + 18.206299795861014, + 22.433367517962324, + 1.4984477476291431, + -7.4325118779170225, + 13.181849490907553, + 19.59772490600608, + 0.42593354042764986, + -18.325816077129275, + 13.411881841817376, + 5.89494109214138 + ] + ], + "branch_cpu": [ + [ + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 2, + 1, + 1, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 6, + 1, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + ], + "branch_frz": [ + [ + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 3, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 1, + 2, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 1, + 1 + ], + [ + 2, + 1, + 1, + 4, + 4, + 1, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 1, + 1, + 1, + 4, + 4, + 1, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 1, + 1 + ], + [ + 6, + 1, + 1, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 1, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + [ + 4, + 4, + 4, + 4, + 1, + 2, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + ] + } +} \ No newline at end of file diff --git a/python/tests/branch_site_dump.py b/python/tests/branch_site_dump.py new file mode 100644 index 00000000..ef64ef56 --- /dev/null +++ b/python/tests/branch_site_dump.py @@ -0,0 +1,133 @@ +"""Dump one Test3 divergence site in full, for the annex figure. + +Re-runs both finders up to the target frame and, at that frame, records the +3x3 neighbourhood as each model saw it: raw ADU, the pedestal mean each model +was reading, the resulting pedestal-subtracted values, and both test statistics +against their thresholds. + +The site is the first frame at which a Test3 flip creates a cluster in the +frozen finder that the serial finder does not produce. + +Writes branch_site.json next to itself. + +REQUIRES a build with branch tracing on, which is OFF by default so the +shipped path carries no per-pixel store: + + sed -i 's/#define AARE_BRANCH_TRACE 0/#define AARE_BRANCH_TRACE 1/' \ + include/aare/ClusterFinder.hpp include/aare/ClusterFinderFrozen.hpp + cmake --build build -j8 + +Set it back to 0 afterwards. Without it branch_map is all-5 and this +script reports no divergence at all. +""" +import sys, json +sys.path.append('/home/ferjao_k/aare/build') +sys.path.append('/home/ferjao_k/aare/python/tests') + +from pathlib import Path +import numpy as np +from aare import File, ClusterFinder, ClusterFinderFrozen + +OUT = Path(__file__).resolve().parent +BASE = Path('/mnt/sls_det_storage/moench_data/2603_MaxIVBeamtime/2026032408/' + 'process/xrf/') + +N_PED, N_SIGMA = 1000, 5 +CLUSTER, IMG, CAP = (3, 3), (400, 400), 50_000 +TARGET_FRAME, TY, TX = 203, 125, 245 # from branch_trace.json +C3 = np.sqrt(9.0) # sqrt(ClusterSizeX * ClusterSizeY) + +f = File(BASE / 'Cu_factor_10_data_master_0.json') +pd = File(BASE / 'Cu_factor_10_pedestal_master_0.json') + +cf_cpu = ClusterFinder(IMG, CLUSTER, n_sigma=N_SIGMA, capacity=CAP) +cf_frz = ClusterFinderFrozen(IMG, CLUSTER, n_sigma=N_SIGMA, capacity=CAP) + +pd.seek(0) +for _ in range(N_PED): + img = pd.read_frame().copy() + cf_cpu.push_pedestal_frame(img) + cf_frz.push_pedestal_frame(img) + +f.seek(0) +data = f.read_n(TARGET_FRAME + 1) + +# state entering the target frame +for fid in range(TARGET_FRAME): + cf_cpu.find_clusters(data[fid]); cf_cpu.steal_clusters(realloc_same_capacity=True) + cf_frz.find_clusters(data[fid]); cf_frz.steal_clusters(realloc_same_capacity=True) + +ped_cpu_before = np.asarray(cf_cpu.pedestal).copy() +ped_frz_before = np.asarray(cf_frz.pedestal).copy() +rms_cpu_before = np.asarray(cf_cpu.noise).copy() +rms_frz_before = np.asarray(cf_frz.noise).copy() + +# the frame itself +cf_cpu.find_clusters(data[TARGET_FRAME]) +cf_frz.find_clusters(data[TARGET_FRAME]) +b_cpu = np.asarray(cf_cpu.branch_map) +b_frz = np.asarray(cf_frz.branch_map) + +sl = (slice(TY - 1, TY + 2), slice(TX - 1, TX + 2)) +raw = data[TARGET_FRAME][sl].astype(float) + +# The frozen model reads its frame-start snapshot for the whole frame, so +# ped_frz_before IS what it used. The serial model's 3-above/1-left neighbours +# may already carry this frame's sample by the time (TY,TX) is tested, so its +# effective pedestal is read AFTER the frame -- but only for pixels it pushed. +ped_cpu_after = np.asarray(cf_cpu.pedestal).copy() + +# raster order: the four already-scanned neighbours of (TY,TX) +scanned = np.zeros((3, 3), dtype=bool) +scanned[0, :] = True # the row above: (-1,-1) (-1,0) (-1,+1) +scanned[1, 0] = True # and the pixel to the left + +ped_cpu_used = np.where(scanned, ped_cpu_after[sl], ped_cpu_before[sl]) +ped_frz_used = ped_frz_before[sl] + +val_cpu = raw - ped_cpu_used +val_frz = raw - ped_frz_used +rms = float(rms_frz_before[TY, TX]) + +rec = dict( + frame=TARGET_FRAME, iy=TY, ix=TX, n_sigma=N_SIGMA, c3=float(C3), + raw=raw.tolist(), + ped_cpu=ped_cpu_used.tolist(), ped_frz=ped_frz_used.tolist(), + val_cpu=val_cpu.tolist(), val_frz=val_frz.tolist(), + scanned=scanned.tolist(), + rms_cpu=float(rms_cpu_before[TY, TX]), rms_frz=rms, + total_cpu=float(val_cpu.sum()), total_frz=float(val_frz.sum()), + max_cpu=float(val_cpu.max()), max_frz=float(val_frz.max()), + value_cpu=float(val_cpu[1, 1]), value_frz=float(val_frz[1, 1]), + thr_test1_cpu=float(N_SIGMA * rms_cpu_before[TY, TX]), + thr_test1_frz=float(N_SIGMA * rms), + thr_test3_cpu=float(C3 * N_SIGMA * rms_cpu_before[TY, TX]), + thr_test3_frz=float(C3 * N_SIGMA * rms), + branch_cpu=int(b_cpu[TY, TX]), branch_frz=int(b_frz[TY, TX]), +) +# A wider patch for the context panel: what the raster was doing around the +# site. Branch codes come from the SERIAL finder, since the left panel's job is +# to show the scan in progress. +R = 10 +py0, px0 = TY - R, TX - R +pat = (slice(py0, TY + R + 1), slice(px0, TX + R + 1)) +rec["patch"] = dict( + r=R, y0=int(py0), x0=int(px0), + val=(data[TARGET_FRAME][pat].astype(float) - ped_frz_before[pat]).tolist(), + branch_cpu=b_cpu[pat].astype(int).tolist(), + branch_frz=b_frz[pat].astype(int).tolist(), +) + +json.dump(rec, open(OUT / 'branch_site.json', 'w'), indent=1) + +print(f"frame {TARGET_FRAME}, pixel ({TY},{TX}) branch cpu={rec['branch_cpu']} " + f"frozen={rec['branch_frz']} (4=QUIET_UPDATE, 3=TEST3_STORE)") +print(f" rms {rms:.3f} Test1 thr {rec['thr_test1_frz']:.2f} " + f"Test3 thr {rec['thr_test3_frz']:.2f}") +print(f" serial : max {rec['max_cpu']:8.3f} total {rec['total_cpu']:8.3f} " + f"-> Test3 {'PASS' if rec['total_cpu'] > rec['thr_test3_cpu'] else 'fail'}") +print(f" frozen : max {rec['max_frz']:8.3f} total {rec['total_frz']:8.3f} " + f"-> Test3 {'PASS' if rec['total_frz'] > rec['thr_test3_frz'] else 'fail'}") +print(f" the four already-scanned neighbours differ by " + f"{np.abs(ped_cpu_used - ped_frz_used)[scanned].sum():.4f} ADU total") +print(f"wrote {OUT / 'branch_site.json'}") diff --git a/python/tests/branch_trace.json b/python/tests/branch_trace.json new file mode 100644 index 00000000..f76c161c --- /dev/null +++ b/python/tests/branch_trace.json @@ -0,0 +1,2826 @@ +{ + "n_frames": 10000, + "n_ped": 1000, + "n_sigma": 5, + "clusters": { + "cpu": 23244602, + "frozen": 23244605 + }, + "centre_diff": { + "cpu_only": 8, + "frozen_only": 11 + }, + "first_divergent_frame": 4, + "transitions": { + "QUIET_UPDATE->TEST3_SKIP": 335, + "QUIET_UPDATE->SHADOW": 593, + "QUIET_UPDATE->TEST3_STORE": 11, + "TEST3_SKIP->SHADOW": 15, + "SHADOW->QUIET_UPDATE": 11, + "TEST3_STORE->TEST3_SKIP": 5, + "TEST1_STORE->SHADOW": 3, + "TEST3_SKIP->QUIET_UPDATE": 1 + }, + "sites": [ + { + "frame": 4, + "iy": 37, + "ix": 348, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4, + "iy": 166, + "ix": 243, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 9, + "iy": 322, + "ix": 298, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 15, + "iy": 329, + "ix": 354, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 30, + "iy": 239, + "ix": 297, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 34, + "iy": 398, + "ix": 181, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 43, + "iy": 64, + "ix": 275, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 53, + "iy": 48, + "ix": 127, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 59, + "iy": 152, + "ix": 298, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 68, + "iy": 22, + "ix": 344, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 80, + "iy": 188, + "ix": 185, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 83, + "iy": 345, + "ix": 355, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 100, + "iy": 161, + "ix": 384, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 107, + "iy": 358, + "ix": 140, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 127, + "iy": 193, + "ix": 50, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 131, + "iy": 28, + "ix": 331, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 203, + "iy": 125, + "ix": 245, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_STORE" + }, + { + "frame": 218, + "iy": 398, + "ix": 284, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 230, + "iy": 16, + "ix": 166, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 230, + "iy": 114, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 234, + "iy": 382, + "ix": 55, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 243, + "iy": 284, + "ix": 18, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 271, + "iy": 6, + "ix": 229, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 273, + "iy": 44, + "ix": 273, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 278, + "iy": 5, + "ix": 185, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 302, + "iy": 268, + "ix": 64, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 310, + "iy": 381, + "ix": 339, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 339, + "iy": 134, + "ix": 214, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 363, + "iy": 69, + "ix": 275, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 377, + "iy": 190, + "ix": 250, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 382, + "iy": 136, + "ix": 191, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 391, + "iy": 167, + "ix": 381, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 405, + "iy": 260, + "ix": 33, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 431, + "iy": 300, + "ix": 2, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 463, + "iy": 117, + "ix": 182, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 482, + "iy": 253, + "ix": 0, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 498, + "iy": 169, + "ix": 125, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 509, + "iy": 230, + "ix": 211, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 514, + "iy": 225, + "ix": 202, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 522, + "iy": 14, + "ix": 263, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 538, + "iy": 347, + "ix": 28, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 550, + "iy": 222, + "ix": 23, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 563, + "iy": 302, + "ix": 92, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 576, + "iy": 316, + "ix": 20, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 589, + "iy": 113, + "ix": 273, + "cpu": "TEST3_SKIP", + "frozen": "SHADOW" + }, + { + "frame": 606, + "iy": 233, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 623, + "iy": 307, + "ix": 102, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 646, + "iy": 144, + "ix": 24, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 665, + "iy": 90, + "ix": 330, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_STORE" + }, + { + "frame": 692, + "iy": 78, + "ix": 16, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 693, + "iy": 345, + "ix": 372, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 718, + "iy": 51, + "ix": 221, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 718, + "iy": 398, + "ix": 95, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 746, + "iy": 89, + "ix": 60, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 747, + "iy": 364, + "ix": 253, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 752, + "iy": 218, + "ix": 29, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 754, + "iy": 167, + "ix": 208, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 771, + "iy": 218, + "ix": 399, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 773, + "iy": 299, + "ix": 7, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 778, + "iy": 74, + "ix": 263, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 789, + "iy": 221, + "ix": 125, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 796, + "iy": 46, + "ix": 357, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 796, + "iy": 275, + "ix": 86, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 809, + "iy": 90, + "ix": 301, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 809, + "iy": 133, + "ix": 337, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 823, + "iy": 63, + "ix": 273, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 843, + "iy": 154, + "ix": 231, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 844, + "iy": 398, + "ix": 233, + "cpu": "TEST3_SKIP", + "frozen": "SHADOW" + }, + { + "frame": 854, + "iy": 95, + "ix": 203, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 864, + "iy": 300, + "ix": 3, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 866, + "iy": 115, + "ix": 221, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 867, + "iy": 343, + "ix": 65, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 868, + "iy": 84, + "ix": 32, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 872, + "iy": 188, + "ix": 305, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 873, + "iy": 218, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 888, + "iy": 218, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 899, + "iy": 242, + "ix": 370, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 904, + "iy": 66, + "ix": 185, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 906, + "iy": 22, + "ix": 127, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 935, + "iy": 93, + "ix": 277, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 938, + "iy": 54, + "ix": 245, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 956, + "iy": 291, + "ix": 129, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 959, + "iy": 238, + "ix": 187, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 966, + "iy": 192, + "ix": 59, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 970, + "iy": 233, + "ix": 83, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 978, + "iy": 86, + "ix": 163, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 979, + "iy": 240, + "ix": 26, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 986, + "iy": 327, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 994, + "iy": 182, + "ix": 234, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 997, + "iy": 398, + "ix": 365, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_STORE" + }, + { + "frame": 999, + "iy": 103, + "ix": 126, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1009, + "iy": 398, + "ix": 365, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1015, + "iy": 59, + "ix": 108, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1029, + "iy": 221, + "ix": 273, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1032, + "iy": 74, + "ix": 390, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1035, + "iy": 394, + "ix": 307, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1045, + "iy": 320, + "ix": 322, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1058, + "iy": 219, + "ix": 31, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1066, + "iy": 92, + "ix": 126, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1084, + "iy": 83, + "ix": 333, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1088, + "iy": 298, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1109, + "iy": 217, + "ix": 33, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1117, + "iy": 363, + "ix": 203, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1127, + "iy": 37, + "ix": 135, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1127, + "iy": 193, + "ix": 245, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1135, + "iy": 13, + "ix": 398, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1147, + "iy": 245, + "ix": 229, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1159, + "iy": 219, + "ix": 32, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1173, + "iy": 161, + "ix": 244, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1176, + "iy": 221, + "ix": 125, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1188, + "iy": 75, + "ix": 378, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1189, + "iy": 336, + "ix": 51, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1207, + "iy": 295, + "ix": 209, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1213, + "iy": 218, + "ix": 32, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1215, + "iy": 161, + "ix": 282, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1223, + "iy": 217, + "ix": 33, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1224, + "iy": 145, + "ix": 169, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1230, + "iy": 338, + "ix": 101, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1256, + "iy": 167, + "ix": 381, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1280, + "iy": 138, + "ix": 254, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1280, + "iy": 218, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1296, + "iy": 232, + "ix": 169, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1297, + "iy": 249, + "ix": 136, + "cpu": "TEST3_SKIP", + "frozen": "SHADOW" + }, + { + "frame": 1299, + "iy": 398, + "ix": 114, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1311, + "iy": 88, + "ix": 345, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1312, + "iy": 159, + "ix": 167, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1315, + "iy": 99, + "ix": 378, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1317, + "iy": 158, + "ix": 12, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1335, + "iy": 70, + "ix": 388, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1343, + "iy": 161, + "ix": 244, + "cpu": "SHADOW", + "frozen": "QUIET_UPDATE" + }, + { + "frame": 1345, + "iy": 145, + "ix": 60, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1346, + "iy": 4, + "ix": 334, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1360, + "iy": 72, + "ix": 288, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1362, + "iy": 158, + "ix": 210, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1366, + "iy": 398, + "ix": 23, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1383, + "iy": 302, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1384, + "iy": 70, + "ix": 106, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1393, + "iy": 121, + "ix": 399, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1418, + "iy": 297, + "ix": 399, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1420, + "iy": 126, + "ix": 78, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1429, + "iy": 51, + "ix": 84, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1452, + "iy": 149, + "ix": 3, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1453, + "iy": 398, + "ix": 37, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1476, + "iy": 218, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1496, + "iy": 237, + "ix": 225, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1501, + "iy": 216, + "ix": 34, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1505, + "iy": 228, + "ix": 397, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1533, + "iy": 298, + "ix": 7, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1543, + "iy": 147, + "ix": 106, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1553, + "iy": 341, + "ix": 237, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1564, + "iy": 208, + "ix": 363, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1568, + "iy": 2, + "ix": 42, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1578, + "iy": 333, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1579, + "iy": 53, + "ix": 137, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1590, + "iy": 56, + "ix": 36, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1590, + "iy": 87, + "ix": 157, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1590, + "iy": 334, + "ix": 215, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_STORE" + }, + { + "frame": 1618, + "iy": 242, + "ix": 209, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1634, + "iy": 215, + "ix": 268, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1636, + "iy": 7, + "ix": 275, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1645, + "iy": 194, + "ix": 191, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1648, + "iy": 48, + "ix": 126, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1660, + "iy": 98, + "ix": 328, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1663, + "iy": 322, + "ix": 315, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1666, + "iy": 96, + "ix": 76, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1672, + "iy": 363, + "ix": 203, + "cpu": "SHADOW", + "frozen": "QUIET_UPDATE" + }, + { + "frame": 1685, + "iy": 73, + "ix": 328, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1688, + "iy": 89, + "ix": 283, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1694, + "iy": 245, + "ix": 233, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1721, + "iy": 209, + "ix": 276, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1734, + "iy": 349, + "ix": 247, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1748, + "iy": 206, + "ix": 214, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1751, + "iy": 307, + "ix": 102, + "cpu": "TEST3_SKIP", + "frozen": "SHADOW" + }, + { + "frame": 1752, + "iy": 112, + "ix": 135, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1775, + "iy": 219, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1778, + "iy": 398, + "ix": 164, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1791, + "iy": 60, + "ix": 245, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1791, + "iy": 296, + "ix": 249, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1792, + "iy": 148, + "ix": 169, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1820, + "iy": 287, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1835, + "iy": 69, + "ix": 304, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1835, + "iy": 121, + "ix": 204, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1835, + "iy": 394, + "ix": 204, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1837, + "iy": 188, + "ix": 13, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1844, + "iy": 207, + "ix": 189, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1855, + "iy": 152, + "ix": 202, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1891, + "iy": 228, + "ix": 342, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1897, + "iy": 137, + "ix": 115, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1899, + "iy": 65, + "ix": 271, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1916, + "iy": 54, + "ix": 189, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1917, + "iy": 194, + "ix": 235, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1928, + "iy": 296, + "ix": 212, + "cpu": "TEST3_STORE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1941, + "iy": 381, + "ix": 143, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1944, + "iy": 156, + "ix": 32, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1956, + "iy": 298, + "ix": 7, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1962, + "iy": 50, + "ix": 58, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1974, + "iy": 160, + "ix": 245, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1974, + "iy": 241, + "ix": 286, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 1979, + "iy": 240, + "ix": 22, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 1979, + "iy": 398, + "ix": 150, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2012, + "iy": 366, + "ix": 209, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2015, + "iy": 235, + "ix": 99, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2016, + "iy": 156, + "ix": 356, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2038, + "iy": 108, + "ix": 7, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2064, + "iy": 125, + "ix": 8, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2068, + "iy": 379, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2069, + "iy": 366, + "ix": 287, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2086, + "iy": 398, + "ix": 381, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2090, + "iy": 356, + "ix": 4, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2105, + "iy": 9, + "ix": 114, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2119, + "iy": 87, + "ix": 10, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2119, + "iy": 366, + "ix": 375, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2135, + "iy": 168, + "ix": 20, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2138, + "iy": 37, + "ix": 233, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2141, + "iy": 15, + "ix": 273, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2141, + "iy": 386, + "ix": 237, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2142, + "iy": 94, + "ix": 383, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2155, + "iy": 77, + "ix": 10, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2197, + "iy": 313, + "ix": 81, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2217, + "iy": 398, + "ix": 185, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2221, + "iy": 2, + "ix": 62, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2247, + "iy": 115, + "ix": 198, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2247, + "iy": 398, + "ix": 101, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2251, + "iy": 218, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2269, + "iy": 277, + "ix": 156, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2294, + "iy": 121, + "ix": 251, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2306, + "iy": 277, + "ix": 156, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2307, + "iy": 365, + "ix": 18, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2308, + "iy": 1, + "ix": 248, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2328, + "iy": 293, + "ix": 180, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2344, + "iy": 245, + "ix": 265, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2356, + "iy": 130, + "ix": 213, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2358, + "iy": 397, + "ix": 396, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2364, + "iy": 152, + "ix": 108, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2364, + "iy": 298, + "ix": 7, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2384, + "iy": 74, + "ix": 110, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2399, + "iy": 172, + "ix": 363, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2426, + "iy": 392, + "ix": 293, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2434, + "iy": 141, + "ix": 376, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2457, + "iy": 238, + "ix": 378, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2493, + "iy": 335, + "ix": 91, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2495, + "iy": 267, + "ix": 160, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2506, + "iy": 124, + "ix": 245, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2562, + "iy": 217, + "ix": 140, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2586, + "iy": 396, + "ix": 338, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2587, + "iy": 317, + "ix": 22, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2604, + "iy": 175, + "ix": 302, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2611, + "iy": 376, + "ix": 398, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2615, + "iy": 398, + "ix": 175, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2623, + "iy": 375, + "ix": 321, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2632, + "iy": 91, + "ix": 146, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2633, + "iy": 365, + "ix": 18, + "cpu": "SHADOW", + "frozen": "QUIET_UPDATE" + }, + { + "frame": 2642, + "iy": 4, + "ix": 364, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2644, + "iy": 192, + "ix": 208, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2655, + "iy": 232, + "ix": 84, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2657, + "iy": 197, + "ix": 243, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2661, + "iy": 270, + "ix": 79, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2665, + "iy": 232, + "ix": 84, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2674, + "iy": 399, + "ix": 99, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2675, + "iy": 138, + "ix": 151, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2678, + "iy": 217, + "ix": 72, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2685, + "iy": 398, + "ix": 255, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2733, + "iy": 119, + "ix": 108, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2736, + "iy": 218, + "ix": 29, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2737, + "iy": 285, + "ix": 95, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2770, + "iy": 89, + "ix": 352, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2810, + "iy": 65, + "ix": 132, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2818, + "iy": 276, + "ix": 83, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2822, + "iy": 313, + "ix": 267, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_STORE" + }, + { + "frame": 2869, + "iy": 322, + "ix": 285, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2870, + "iy": 142, + "ix": 239, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2899, + "iy": 382, + "ix": 56, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2911, + "iy": 285, + "ix": 18, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2927, + "iy": 131, + "ix": 86, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 2945, + "iy": 198, + "ix": 243, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2948, + "iy": 308, + "ix": 293, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2950, + "iy": 65, + "ix": 16, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2952, + "iy": 397, + "ix": 269, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_STORE" + }, + { + "frame": 2963, + "iy": 84, + "ix": 359, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2965, + "iy": 255, + "ix": 50, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2974, + "iy": 232, + "ix": 81, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2991, + "iy": 242, + "ix": 318, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 2993, + "iy": 286, + "ix": 233, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3004, + "iy": 364, + "ix": 68, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3046, + "iy": 2, + "ix": 373, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3046, + "iy": 118, + "ix": 135, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3049, + "iy": 103, + "ix": 276, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3053, + "iy": 398, + "ix": 298, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3058, + "iy": 387, + "ix": 146, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3059, + "iy": 258, + "ix": 17, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3072, + "iy": 114, + "ix": 268, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3100, + "iy": 83, + "ix": 95, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3100, + "iy": 203, + "ix": 320, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3100, + "iy": 300, + "ix": 126, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3115, + "iy": 190, + "ix": 83, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3119, + "iy": 135, + "ix": 157, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3147, + "iy": 321, + "ix": 219, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3155, + "iy": 158, + "ix": 171, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3158, + "iy": 268, + "ix": 163, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3165, + "iy": 293, + "ix": 231, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3166, + "iy": 260, + "ix": 195, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3184, + "iy": 233, + "ix": 257, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3205, + "iy": 44, + "ix": 263, + "cpu": "TEST1_STORE", + "frozen": "SHADOW" + }, + { + "frame": 3208, + "iy": 137, + "ix": 390, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3257, + "iy": 143, + "ix": 144, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3261, + "iy": 14, + "ix": 175, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3264, + "iy": 143, + "ix": 275, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3285, + "iy": 79, + "ix": 35, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3291, + "iy": 395, + "ix": 130, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3297, + "iy": 229, + "ix": 56, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3315, + "iy": 216, + "ix": 32, + "cpu": "TEST3_SKIP", + "frozen": "SHADOW" + }, + { + "frame": 3325, + "iy": 398, + "ix": 350, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3333, + "iy": 261, + "ix": 247, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3348, + "iy": 232, + "ix": 81, + "cpu": "TEST1_STORE", + "frozen": "SHADOW" + }, + { + "frame": 3356, + "iy": 190, + "ix": 266, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3363, + "iy": 70, + "ix": 246, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3371, + "iy": 126, + "ix": 365, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3372, + "iy": 220, + "ix": 94, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3380, + "iy": 322, + "ix": 141, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3387, + "iy": 150, + "ix": 242, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3388, + "iy": 62, + "ix": 310, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3402, + "iy": 20, + "ix": 12, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3402, + "iy": 243, + "ix": 70, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3430, + "iy": 288, + "ix": 30, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3452, + "iy": 397, + "ix": 254, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3460, + "iy": 361, + "ix": 225, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3465, + "iy": 378, + "ix": 322, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3479, + "iy": 146, + "ix": 104, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3486, + "iy": 136, + "ix": 117, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3500, + "iy": 179, + "ix": 383, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3533, + "iy": 80, + "ix": 365, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3545, + "iy": 13, + "ix": 315, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3579, + "iy": 53, + "ix": 33, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3580, + "iy": 242, + "ix": 317, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3588, + "iy": 15, + "ix": 384, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3591, + "iy": 245, + "ix": 235, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3598, + "iy": 121, + "ix": 73, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3605, + "iy": 145, + "ix": 231, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3606, + "iy": 137, + "ix": 220, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3622, + "iy": 277, + "ix": 395, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3630, + "iy": 156, + "ix": 285, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3675, + "iy": 398, + "ix": 170, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3695, + "iy": 174, + "ix": 369, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3713, + "iy": 96, + "ix": 300, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3728, + "iy": 174, + "ix": 106, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3735, + "iy": 235, + "ix": 384, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3752, + "iy": 148, + "ix": 233, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3776, + "iy": 22, + "ix": 359, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3784, + "iy": 305, + "ix": 102, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3791, + "iy": 12, + "ix": 58, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3801, + "iy": 378, + "ix": 153, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3801, + "iy": 387, + "ix": 317, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3804, + "iy": 355, + "ix": 8, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3805, + "iy": 37, + "ix": 259, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3805, + "iy": 46, + "ix": 207, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3811, + "iy": 2, + "ix": 219, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3818, + "iy": 302, + "ix": 254, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3821, + "iy": 147, + "ix": 205, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3830, + "iy": 130, + "ix": 139, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3860, + "iy": 220, + "ix": 368, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3863, + "iy": 154, + "ix": 120, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3864, + "iy": 398, + "ix": 389, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3895, + "iy": 280, + "ix": 42, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3895, + "iy": 380, + "ix": 223, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3897, + "iy": 148, + "ix": 16, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3900, + "iy": 398, + "ix": 169, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3911, + "iy": 244, + "ix": 100, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 3928, + "iy": 99, + "ix": 368, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3948, + "iy": 251, + "ix": 32, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3950, + "iy": 15, + "ix": 261, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 3956, + "iy": 212, + "ix": 236, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4001, + "iy": 373, + "ix": 1, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4015, + "iy": 35, + "ix": 358, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4036, + "iy": 1, + "ix": 263, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4044, + "iy": 309, + "ix": 221, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4075, + "iy": 288, + "ix": 86, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4120, + "iy": 277, + "ix": 284, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4134, + "iy": 125, + "ix": 95, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4139, + "iy": 50, + "ix": 275, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4168, + "iy": 318, + "ix": 333, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4168, + "iy": 329, + "ix": 333, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4170, + "iy": 27, + "ix": 343, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4171, + "iy": 59, + "ix": 185, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4174, + "iy": 205, + "ix": 321, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4189, + "iy": 397, + "ix": 269, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_STORE" + }, + { + "frame": 4204, + "iy": 219, + "ix": 29, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4212, + "iy": 235, + "ix": 60, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4212, + "iy": 322, + "ix": 390, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4230, + "iy": 75, + "ix": 296, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4243, + "iy": 381, + "ix": 225, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4264, + "iy": 394, + "ix": 235, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4266, + "iy": 55, + "ix": 236, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4281, + "iy": 193, + "ix": 4, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4292, + "iy": 46, + "ix": 355, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4293, + "iy": 240, + "ix": 20, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4316, + "iy": 53, + "ix": 267, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4316, + "iy": 339, + "ix": 323, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4331, + "iy": 230, + "ix": 94, + "cpu": "QUIET_UPDATE", + "frozen": "TEST3_SKIP" + }, + { + "frame": 4334, + "iy": 394, + "ix": 241, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + }, + { + "frame": 4338, + "iy": 142, + "ix": 239, + "cpu": "QUIET_UPDATE", + "frozen": "SHADOW" + } + ] +} \ No newline at end of file diff --git a/python/tests/branch_trace.py b/python/tests/branch_trace.py new file mode 100644 index 00000000..47fb0a1f --- /dev/null +++ b/python/tests/branch_trace.py @@ -0,0 +1,148 @@ +"""Which test is responsible for the serial-vs-frozen disagreement? + +ClusterFinder and ClusterFinderFrozen differ in exactly one thing: WHEN the +pedestal is pushed. `push_fast` touches only the pixel's own accumulators and +never reads the stencil, so the update itself is order-independent: given the +same set of updated pixels, both models end a frame with a bit-identical +pedestal. The only channel for divergence is therefore a differing DECISION. + +There are three places a decision can differ, and they are not equally exposed: + + Test1 max > nSigma*rms reads the stencil MAX. + local-max gate v == m compares two stencil values. + Test3 total > c3*nSigma*rms reads the stencil SUM, so it collects the + shift of every already-scanned neighbour -- + three above and one left -- where Test1 feels + at most the one that happens to be the argmax. + +WHAT THIS ACTUALLY FOUND (the prior stated here before running it was only half +right, so it is recorded as measured rather than as predicted): + + * Every cluster frozen finds and serial does not -- 11 of them -- comes from + Test3. Compiling Test3 out sends that count to exactly zero. + * Every cluster serial finds and frozen does not -- 8 -- comes from the + local-max gate, downstream of accumulated pedestal drift. + * Test1's threshold flips MOST often, 619 of 974 divergent pixels, and yields + ZERO clusters: it only moves a pixel between QUIET_UPDATE and SHADOW, and + neither of those stores. + * Test1 is not merely downstream of Test3. With Test3 ablated the first + divergence is still a Test1 flip, on a frame where the two pedestals were + provably identical. It initiates on its own, just ~7x slower (frame 30 + against frame 4), and cannot create a cluster by itself. + +This does not ablate anything -- both finders run their shipped logic. Each +records a per-pixel branch code (see branch_map in either header) and we diff +the two maps frame by frame, which names the guilty test on the real algorithm +and localises it for the annex figure. + +Writes branch_trace.json next to itself. + +REQUIRES a build with branch tracing on, which is OFF by default so the +shipped path carries no per-pixel store: + + sed -i 's/#define AARE_BRANCH_TRACE 0/#define AARE_BRANCH_TRACE 1/' \ + include/aare/ClusterFinder.hpp include/aare/ClusterFinderFrozen.hpp + cmake --build build -j8 + +Set it back to 0 afterwards. Without it branch_map is all-5 and this +script reports no divergence at all. +""" +import sys, json, time +sys.path.append('/home/ferjao_k/aare/build') +sys.path.append('/home/ferjao_k/aare/python/tests') + +from pathlib import Path +from collections import Counter +import numpy as np + +from aare import File, ClusterFinder, ClusterFinderFrozen +from helper import centers, only_sets + +OUT = Path(__file__).resolve().parent +BASE = Path('/mnt/sls_det_storage/moench_data/2603_MaxIVBeamtime/2026032408/' + 'process/xrf/') + +N_PED, N, N_SIGMA = 1000, 10000, 5 +CLUSTER = (3, 3) +IMG = (400, 400) +CAP = 50_000 + +CODE = {0: "NEG", 1: "SHADOW", 2: "TEST1_STORE", 3: "TEST3_STORE", + 6: "TEST3_SKIP", 4: "QUIET_UPDATE", 5: "UNTOUCHED"} + +f = File(BASE / 'Cu_factor_10_data_master_0.json') +pd = File(BASE / 'Cu_factor_10_pedestal_master_0.json') + +cf_cpu = ClusterFinder(IMG, CLUSTER, n_sigma=N_SIGMA, capacity=CAP) +cf_frz = ClusterFinderFrozen(IMG, CLUSTER, n_sigma=N_SIGMA, capacity=CAP) + +t0 = time.perf_counter() +pd.seek(0) +for _ in range(N_PED): + img = pd.read_frame().copy() + cf_cpu.push_pedestal_frame(img) + cf_frz.push_pedestal_frame(img) +print(f'pedestal train: {time.perf_counter()-t0:.1f}s', flush=True) + +f.seek(0) +data = f.read_n(N) +print('data:', data.shape, data.dtype, flush=True) + +# (cpu_code, frozen_code) -> count, over every pixel where the two maps differ +transitions = Counter() +# the first frame at which the branch maps diverge at all +first_div = None +# per-frame centre-set difference, to reproduce the 8/11 headline +cpu_only_tot = frz_only_tot = 0 +n_cpu = n_frz = 0 +# every divergent pixel, kept for the figure (there should be very few) +sites = [] + +t0 = time.perf_counter() +for fid in range(N): + cf_cpu.find_clusters(data[fid]) + cf_frz.find_clusters(data[fid]) + b_cpu = np.asarray(cf_cpu.branch_map) + b_frz = np.asarray(cf_frz.branch_map) + + cv_cpu = cf_cpu.steal_clusters(realloc_same_capacity=True) + cv_frz = cf_frz.steal_clusters(realloc_same_capacity=True) + c_cpu, c_frz = centers(cv_cpu), centers(cv_frz) + n_cpu += len(c_cpu); n_frz += len(c_frz) + a_only, b_only = only_sets(c_cpu, c_frz, tol=0) + cpu_only_tot += len(a_only); frz_only_tot += len(b_only) + + diff = np.argwhere(b_cpu != b_frz) + if diff.size: + if first_div is None: + first_div = int(fid) + for iy, ix in diff: + pair = (int(b_cpu[iy, ix]), int(b_frz[iy, ix])) + transitions[pair] += 1 + if len(sites) < 400: + sites.append(dict(frame=int(fid), iy=int(iy), ix=int(ix), + cpu=CODE[pair[0]], frozen=CODE[pair[1]])) + if (fid + 1) % 2000 == 0: + print(f' {fid+1}/{N} divergent pixels so far: ' + f'{sum(transitions.values())}', flush=True) + +dt = time.perf_counter() - t0 +print(f'\nscan: {dt:.1f}s') +print(f'clusters: cpu {n_cpu} frozen {n_frz}') +print(f'centre-set difference (the 8/11 headline): ' + f'cpu-only {cpu_only_tot} frozen-only {frz_only_tot}') +print(f'first frame with any branch divergence: {first_div}') +print(f'\ndivergent pixels, by (cpu branch -> frozen branch):') +for (a, b), n in transitions.most_common(): + print(f' {CODE[a]:>12} -> {CODE[b]:<12} {n:>8}') + +json.dump(dict(n_frames=N, n_ped=N_PED, n_sigma=N_SIGMA, + clusters=dict(cpu=n_cpu, frozen=n_frz), + centre_diff=dict(cpu_only=cpu_only_tot, + frozen_only=frz_only_tot), + first_divergent_frame=first_div, + transitions={f'{CODE[a]}->{CODE[b]}': n + for (a, b), n in transitions.items()}, + sites=sites), + open(OUT / 'branch_trace.json', 'w'), indent=1) +print(f'\nwrote {OUT / "branch_trace.json"}')