From 47b087e6157ed4276647800aad4c18b9eea29023 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 22:49:06 +0000 Subject: [PATCH 1/9] D-HOLO H14c: pre-registration (thought-first reads, Hamming presence, Lance 13 masked I/O) Pre-registered before any benchmark: the read contract (handles from the program, read at address i, tables consulted == requested lanes), presence populations through mask-risc, three execution paths measured apart, the memory grid, the Lance 13 masked-I/O prediction, coordinate identity scenarios, oracles, disable runs and decision rules. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .claude/board/INTEGRATION_PLANS.md | 8 + .claude/board/STATUS_BOARD.md | 1 + .claude/plans/d-holo-h14c-thought-first-v1.md | 320 ++++++++++++++++++ 3 files changed, 329 insertions(+) create mode 100644 .claude/plans/d-holo-h14c-thought-first-v1.md diff --git a/.claude/board/INTEGRATION_PLANS.md b/.claude/board/INTEGRATION_PLANS.md index 7b846772e..f406df5dd 100644 --- a/.claude/board/INTEGRATION_PLANS.md +++ b/.claude/board/INTEGRATION_PLANS.md @@ -1,3 +1,11 @@ +## 2026-10-15 — d-holo-h14c-thought-first-v1 — thought-first positional reads, Hamming presence and Lance 13 masked I/O → `.claude/plans/d-holo-h14c-thought-first-v1.md` + +**Status:** PRE-REGISTERED; nothing measured. D-HOLO-H14c, -1 … -6. + +- Replaces the row-reconstruction question of H14/H14b (arm M withdrawn) with: given thought, operands and Cartesian address, which accesses are unavoidable. `Thought(t)[Table(a)[i] : Table(b)[i]]`. +- Point projection, presence populations (mask-risc AND/OR/XOR/Count) and explicit terminal rows measured apart; tables consulted must equal the requested lanes, independent of the touched tables. +- Memory/fragmentation of 1 MiB positional tables (lazy, eager, sparse); Lance 13 `with_row_addr_prefilter` bytes_read vs unmasked; coordinate identity across append/delete/update/compaction with stale maps refused. + ## 2026-10-14 (2) — metta-polyfill-v1 — Hyperon/MeTTa as a front end over the masking-algebra polyfill → `.claude/plans/metta-polyfill-v1.md` **Status:** PROPOSAL; D-MTP-0 (map + measurements), D-MTP-1 (join probe, measured), D-MTP-1b (range hop, measured) and D-MTP-6 (datafrog oracle) done; D-MTP-2..5 not authorized. diff --git a/.claude/board/STATUS_BOARD.md b/.claude/board/STATUS_BOARD.md index 33d9af721..acee7792a 100644 --- a/.claude/board/STATUS_BOARD.md +++ b/.claude/board/STATUS_BOARD.md @@ -43,6 +43,7 @@ Plan: `.claude/plans/relalg-v1.md`. Crate: `crates/lance-graph-relalg` (own work | **D-HOLO-H11** | Stacked logic: a chain of NAL polyfill bricks at depth 1–8 composed before one evaluation | Queued (pre-registered, not run; after H6b) | answers no single brick gives, == oracle; cost below d separate runs at d = 4; no confidence inflation, gate disable must inflate | | **D-HOLO-H12** | Semantic map of inference functions across OpenNARS, ONA, the NAL polyfill (and a MeTTa NAL if pinnable) | Queued (pre-registered, not run) | last system adds zero nodes in both orders; polyfill gaps named; differences classified as distinction or defect | | **D-HOLO-H14** | Per classid x thought x 64k tile: full 512-byte row writes vs a connected lane delta (row key + lane mask + changed lanes in one record), and per-(thought, lane) tables indexed directly by the row address (`Lane_l[index]`, no traversal; presence masks folded, materialization charged only at a terminal); session thought masks and thought lane masks kept as separate levels | Measured 2026-10-15 (v4, one class): C folds 10–256× faster than B on F1/F2; C merge-on-read 2.8–6.1× slower than B; C default and B default both not met; returned to the operator with the crossover; H14b (positional per-row lane mask for C) open | == dense reference; C default iff at k <= 4 its fold queries are >= 2x faster than B, its reads with terminal materialization <= 1.25x B and bytes <= B; else B default iff read and session read <= 1.25x A and bytes <= 0.5x A; mixed result returns to the operator | +| **D-HOLO-H14c** | Thought-first positional reads `Thought(t)[Table(a)[i] : Table(b)[i]]`: point projection, presence/Hamming populations through mask-risc, explicit terminal rows; memory and fragmentation of positional tables; Lance 13 masked I/O; coordinate identity across rewrites (sub-ids -1 … -6) | Queued (pre-registered 2026-10-15, plan d-holo-h14c-thought-first-v1; follows H14b, whose arm M is withdrawn as a layout candidate in #1569) | tables consulted == requested lanes for every touched count; at k = 2, U = 31 read <= 1.25x U = 2; populations load no value; no row materialized outside the terminal; no wrong coordinate across rewrites; Lance prediction (1 % uniform mask does not halve bytes_read, 1 % clustered does) | | **D-RA-1** | `Rel` + `normalize` + `symbolic` + R2IL lowering | Shipped #1546 `c21bd165` (11 tests, 11 disable runs red; four comparisons on one lane 8 → 2 ops; 70/2,000 small descriptions refused as written, all run rewritten) | == row oracle over 400 generated descriptions × 5 measures | | **D-RA-2** | Rules into the contract set IR (D-CMR-1/-6); relalg keeps only lowering or is deleted | Queued (maintainer decision) | relalg tests pass unchanged against the contract IR | | **D-RA-3** | Datalog rules as algebra values; names are labels resolved through the label codebook, never strings in a rule | Queued (after D-RA-2) | codebook-built rules == hand-written `Rel`; unknown label refused at resolution | diff --git a/.claude/plans/d-holo-h14c-thought-first-v1.md b/.claude/plans/d-holo-h14c-thought-first-v1.md new file mode 100644 index 000000000..da0d95f71 --- /dev/null +++ b/.claude/plans/d-holo-h14c-thought-first-v1.md @@ -0,0 +1,320 @@ +# D-HOLO-H14c — thought-first positional reads, Hamming presence and Lance 13 masked I/O (v1) + +**Status:** PRE-REGISTERED 2026-10-15; nothing measured. Results will be added +as a dated section below; this pre-registration is not edited after the first +run. + +**D-ids:** D-HOLO-H14c (umbrella), D-HOLO-H14c-1 (point projection and +independence), D-HOLO-H14c-2 (presence/Hamming populations), D-HOLO-H14c-3 +(memory and fragmentation), D-HOLO-H14c-4 (Lance 13 masked I/O), D-HOLO-H14c-5 +(coordinate identity and temporal safety), D-HOLO-H14c-6 (workload harvest). + +**Predecessors:** H14 and H14b in `.claude/plans/d-holo-address-indexed-algebra-v1.md` +(PR #1566 merged, PR #1569 draft); board entry +`2026-10-15-d-holo-h14b-lane-mask.md`. H14b's arm M is withdrawn as a layout +candidate (that plan's "H14b withdrawal note"). + +## Overview + +H14 and H14b asked how cheaply each layout rebuilds a row. C does not need to +rebuild rows for ordinary computation, so that question cannot decide whether C +works. H14c asks instead: + +> If the thought, its operands and the Cartesian address are already known, +> which operations are still necessary, which memory accesses are unavoidable, +> and which materialization and traversal costs disappear? + +Canonical expression: + +``` +Thought(t)[Table(a)[i] : Table(b)[i]] +``` + +- `t` names the thought (the execution perspective); +- the thought's program selects lane tables `a` and `b`; +- `i` is the shared Cartesian row address; +- each selected table is read at position `i`; +- presence says whether a value is there, never where it is; +- merge-on-read combines the selected operands at their common address. + +The thought selects the tables, the address selects the operands, the +instruction operates on them. + +## Checklist + +- [ ] Pre-registration committed before any benchmark (this file). +- [ ] D-HOLO-H14c-1: typed thought-first read (`Selection` → resolved handles → + `read(i)`), with counters; oracle tests; disable runs. +- [ ] D-HOLO-H14c-2: presence populations through mask-risc programs (AND, OR, + XOR, `Count`); scalar reference; disable runs. +- [ ] D-HOLO-H14c-3: memory and fragmentation measures (lazy, eager, sparse); + perf counters where the kernel allows. +- [ ] D-HOLO-H14c-4: Lance 13 masked I/O probe (combined mask + projection; + independent per-lane masks), with `ExecutionSummaryCounts`. +- [ ] D-HOLO-H14c-5: coordinate identity across append, delete, update, + reopen, compaction and version change; stale mapping refused. +- [ ] D-HOLO-H14c-6: lane-selection harvest over the repository's existing + programs, labelled as test-corpus observation. +- [ ] v4 runs with the tier printed; raw results machine-readable. +- [ ] Results section, board entry, STATUS_BOARD, AGENT_LOG, draft PR. + +## 1. Contract: the address is the register + +The 16-byte lane arrangement is a generic register contract. CE64, SPOFC, +NARS evidence, thought identity and the like are typed readings over it, not +fixed meanings of its bytes. H14c reads bytes; it gives them no meaning. + +The fundamental operation is + +``` +read(t, i, L) -> operands +R(t, i, L) = { V[t,l][i] | l in L, P[t,l][i] = 1 } +``` + +with `L` the set of lanes the thought's program requests. Requirements, each a +test in § 6: + +1. Table handles come from the program (resolved once), never from the row. +2. A selected table is read at exactly address `i`. +3. The number of lane tables the thought touched outside `L` does not change + how many tables a read consults. +4. An absent value is decided by one presence bit, not by a search. +5. No 512-byte row is assembled unless a named terminal asks for it. +6. Any address translation is explicit, counted, and outside the direct-position + path. (The sparse arm in § 4 is the only place one exists.) +7. A read may load several lanes but never walks a relation to find them. + +**Absent versus zero.** A read returns, per selected lane, one of +`Overlay(value)` (the thought wrote it), `Base(value)` (fallback to the +immutable base, when the selection asks for fallback) or `Absent` (no overlay +and no fallback). An overlay value of sixteen zero bytes is `Overlay([0; 16])`, +never `Absent`. + +**Precedence.** Thought overlay over base, always. Two thoughts reading the +same `i` see their own overlays; a read reports which thought supplied the +value, so their evidence is not conflated. + +**Authorization and time.** Row-level, field-level, tenant and temporal +restrictions enter as an aperture mask composed before payload is read. A read +under an aperture tests the aperture bit first; a denied address loads no +value. Address equality is not permission, not semantic equality and not +causal entailment. + +**What the thought knows.** It knows which lanes its program requests. It does +not know which lanes are populated at a given row; the presence bit of each +requested table answers that, one test per requested lane. + +## 2. Presence is Hamming geometry + +Each (thought, lane) table has a presence plane `P[t,l]` of 65,536 bits (8 KiB). +Kept distinct: + +| quantity | expression | meaning | +|---|---|---| +| population | `popcount(P)` | how many addresses hold a value | +| shared occupancy | `popcount(Pa & Pb)` | addresses where both operands exist | +| coverage disagreement | `popcount(Pa ^ Pb)` (Hamming distance) | addresses covered by exactly one | +| difference locations | `Pa ^ Pb` | which addresses those are | +| joint availability | `A & Pa & Pb` | operands available under aperture `A` | + +These run as mask-risc programs (`MaskOp::And/Or/Xor`, `Terminal::Count`, +`Terminal::Keep`) over the planes; no new arithmetic. A population query reads +no payload value. + +Equal presence does not mean equal values; Hamming distance between presence +planes is a distance between coverages, not between evidence, meanings or +causes. Presence agreement, value equality, semantic agreement, evidential +independence and causal confidence are five different things and H14c measures +only the first two. + +## 3. Three execution paths, measured apart + +- **A. Addressed point projection** `Thought(t)[Table(a)[i] : Table(b)[i]]`: + handle resolution (once per program, timed separately), presence tests for + the requested lanes, loads of present values, output of the selected + operands. No row is built. +- **B. Address-set population**: `popcount(Pa & Pb & A)`, `popcount(Pt ^ Pu)`, + `popcount(OR(P_t1, …, P_tn))`, through mask-risc. Folds are for populations; + locating one value at a known address needs no fold. +- **C. Explicit terminal materialization**: a named terminal builds a 512-byte + row (base plus every overlay of the thought) only when asked. Timed alone; + not part of the A or B success criteria. + +## 4. Arms + +- **C (positional)**: one table per (thought, lane) the thought touched, + `values: [16 B; 65,536]` indexed by the address, plus `P[t,l]`. Two storage + variants of the same table: **C-lazy** (zeroed allocation; the OS commits a + page on first write) and **C-eager** (every page written at seal). +- **B (connected delta, historical)**: per dirty row one record (lane mask + + changed lanes packed), found through a positional row-to-record index; lane + `l` is a mask test plus a popcount rank. Included to answer "is C faster than + B for query-shaped reads"; its full-row read is not used. +- **S (sparse, explicit translation)**: per (thought, lane) the dirty addresses + sorted with their values; lane `l` at `i` is a binary search. It exists only + to price the memory alternative; its search is the counted address + translation of requirement 6, and it is never called "direct". + +Every arm reads the same fixture and must equal a dense reference before any +timing. + +## 5. Grid (pre-registered; reduced, and the reduction is stated) + +Tile 65,536 addresses, 32 lanes of 16 bytes, deterministic seeds. + +- **Main grid (point projection and populations):** requested lanes + `k ∈ {1, 2, 4, 8, 16, 31}` × dirty density `{0 %, 0.1 %, 1 %, 10 %, 50 %, 100 %}` + × touched tables in the thought `U ∈ {k, 8, 31}` (with `U >= k`), one thought, + uniform scattered addresses, cache-hot and cache-cold. +- **Thought axis:** `T ∈ {1, 8, 64}` at `k = 2`, densities `{1 %, 10 %}`, + `U = 31`, for point reads across thoughts and for the session OR. +- **Spatial axis:** at `k = 2`, densities `{1 %, 10 %}`, `U = 31`: clustered + (runs of 64), uniform scattered, one contiguous range, Morton-local (dirty + addresses inside a few 256-address blocks), disjoint populations between + `a` and `b`, highly overlapping populations (`b`'s dirty set is `a`'s with 10 % + changed). +- **Memory grid:** C-lazy, C-eager and S at `T ∈ {1, 8, 64}` × densities + `{0.1 %, 1 %, 10 %, 100 %}` × spatial `{uniform, clustered}`, `U = 31`. +- **Access patterns:** single addressed value (`k = 1`); two-lane point + projection; repeated point projections (the same 256 addresses); mask + intersection with population count; Hamming distance; session aperture (OR + over thoughts); selected-value merge-on-read; explicit terminal row. + +Not crossed: the full product (6 × 6 × 3 × 3 × 6 × 2 cells, most of them +redundant for the questions asked). Cells outside the grid are not claimed. + +**Cache states.** Hot: the same 256 addresses repeated, after a warm-up pass. +Cold: uniformly random addresses, with a 128 MiB eviction pass before each timed +batch. **Reported unit:** ns per read (point paths), ns per 64-address word +(population paths); medians of 7 batches; the tier the program prints. + +## 6. Correctness oracles (written and green before any timing) + +1. Address `i` returns the exact 16-byte value of every selected lane (dense + reference), on every arm. +2. Presence does not change a value's address (a table's value at `i` is the + reference value regardless of which other addresses are present). +3. `Absent` and `Overlay([0; 16])` are distinguishable. +4. Overlay beats base; fallback to base only when the selection asks for it. +5. Tables consulted by a read equal `|L|` for every `U` (counter, exact). +6. Hamming weight and distance equal a scalar bit loop. +7. AND/OR/XOR populations equal a dense `bool` reference. +8. Independently masked Lance reads equal the reference (§ 7). +9. Permuting the order in which Lance returns rows does not change the + coordinate each value is attributed to (values are matched by their stored + coordinate, never by output position). +10. Compaction and version change never yield a value from the wrong + coordinate: a stale mapping is refused (§ 8). +11. Point projection and population queries materialize no row (counter = 0); + the terminal materializes exactly the rows asked for. +12. Two thoughts reading one coordinate get their own values and their own + thought id. +13. A denied address (aperture bit 0) loads no value. + +**Disable runs** (each must turn its test red; recorded with the test name): +drop a presence test; shift the address by one; substitute an unrelated lane; +probe every touched table; build the full row inside the point read; reuse a +stale mapping after compaction; treat absent as zero; skip the aperture test. + +## 7. Lance 13 masked I/O (D-HOLO-H14c-4) + +Verified against the locally resolved `lance 13.0.0` source: +`Scanner::with_row_addr_prefilter(RowAddrMask)`, `RowAddrMask::from_allowed`, +`RowAddrMask::from_block` (`lance-select 13.0.0`, `mask.rs`), +`RowAddrTreeMap`, `Scanner::project`, `Scanner::materialization_style` +(`Heuristic`, `AllLate`, `AllEarly`, `AllEarlyExcept`), +`Scanner::scan_stats_callback` with `ExecutionSummaryCounts { iops, requests, +bytes_read, … , all_counts, all_times }`. The scanner's own documentation: +the mask is keyed in the dataset's `_rowid` space (the row address when stable +row ids are off, the stable row id when on), and for a plain scan the mask is +the `FilteredReadExec` row source, "so only masked rows are read". Whether that +reduces bytes fetched, or only rows emitted, is the question measured here. + +Fixture: one Lance dataset per tile with an explicit `coord: u32` column (the +Cartesian address) and lane columns `FixedSizeBinary(16)`, nullable (null = +absent). Strategies: + +1. **Combined**: mask = rows where all requested lanes are present (`A & Pa & Pb`), + translated to row addresses; `project(["coord", a, b])`. +2. **Independent**: one masked read per lane with that lane's own mask, then + alignment by the stored `coord` (never by output order). +3. **Unmasked**: the same projection without a mask (the I/O baseline). + +Measured per (strategy, k ∈ {1, 2, 4, 8}, density ∈ {0.1 %, 1 %, 10 %, 50 %, +100 %}, spatial ∈ {uniform, clustered}, materialization ∈ {Heuristic, AllLate, +AllEarly}): `bytes_read`, `iops`, `requests`, rows emitted, wall time, every +key in `all_counts`. Bytes decoded, pages accessed and allocations are not +exposed by the scan statistics; the probe reports which keys exist and states +what it could not measure rather than estimating it. + +**Prediction (HYPOTHESIS).** Lance reads in pages, so a uniformly scattered +1 % mask touches nearly every page of a lane column: at 1 % uniform, +`bytes_read(masked) > 0.5 × bytes_read(unmasked)` (the mask cuts rows emitted, +not bytes fetched). At 1 % clustered, `bytes_read(masked) <= 0.5 × +bytes_read(unmasked)`. Either half failing is reported as such. + +This probe is a separate crate excluded from the workspace +(`crates/holo-lance-masked-io-probe`), depending only on `lance` 13, `arrow` and +`tokio`: no repository-wide dependency change. + +## 8. Coordinate identity and temporal safety (D-HOLO-H14c-5) + +The Cartesian address `i` is the logical substrate address. It is not a Lance +row address (`fragment << 32 | offset`), not a `_rowid`, not a row ordinal and +not an Arrow batch offset. The chain is + +``` +LogicalCoordinate -> DatasetVersion -> LanceRowIdentity -> PhysicalLocation +``` + +The probe keeps a `CoordMap { dataset_version, coord -> row identity }` built by +one scan of `(coord, _rowid)` at a named version, and refuses (`StaleMapping`) +any masked read whose dataset version differs from the map's. Scenarios, each +with and without `enable_stable_row_ids`: initial append; second append; +delete; update; reopen; compaction (`compact_files`); a rewrite that keeps the +row count; version transition; a missing lane dataset; reuse of an old map. +For each, the test asserts either "every returned value carries the requested +coord" or "the read was refused". The disable run reuses the old map after +compaction without the version check and must return a wrong coordinate (that +is the hazard the check removes) or fail its assertion. + +`VersionClock` (`lance-graph-contract::temporal_pov`, #1567) states that a +reordering rewrite needs a new clock; H14c tests the same boundary for row +identity and does not extend the clock. + +## 9. Workload harvest (D-HOLO-H14c-6) + +No corpus of executed thought programs exists in the repository. H14c publishes +an instrument, `lane_footprint(&Program)` (the planes and lanes a mask-risc +program names), and a census over the programs constructed in the repository's +tests and examples, labelled **test-corpus observation, not workload**. No +workload frequency is invented. + +## 10. Decision rules (pre-registered) + +- **Independence (A, B of the acceptance criteria):** tables consulted == `k` + for every `U` (exact, test). Timing: at `k = 2`, ns per read at `U = 31` is at + most 1.25× that at `U = 2`, hot and cold, at every density. Falsified if any + cell exceeds 1.25×. +- **Populations without values (C):** value loads == 0 for every population + query (test); timing reported per 64-address word. +- **No materialization (D):** materialization counter 0 on A and B paths (test). +- **Identity (E):** every § 8 scenario returns the requested coordinates or + refuses; none returns a wrong coordinate. +- **C vs B on query-shaped reads:** reported per cell as C/B; "C faster" where + C/B <= 1.0. No default is decided from it. +- **Memory:** a C-lazy table whose resident size is at least 50 % of 1 MiB + while its payload is under 10 % of 1 MiB is flagged page-dense waste; the + cells where that happens are listed. No mitigation (M, density switching) is + added in H14c. +- **Lance:** the § 7 prediction, both halves. + +Mixed results return to the operator with the numbers. No universally optimal +layout is claimed. + +## 11. Run record + +Each run records: the tier the program prints, `rustc --version`, the resolved +`lance` version, `MemTotal`, iterations per batch, the command line, and the +git sha. Raw results go to `.claude/board/entries/` as a dated machine-readable +block (CSV inside the entry) and the console output to the session scratchpad. From 44a1cc3d3b2ee210a115fd77bd162853c5a4a2e6 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 22:53:53 +0000 Subject: [PATCH 2/9] D-HOLO H14c: thought-first probe (point projection, mask-risc populations, terminal row), 10 oracle tests Selection -> resolved handles -> read at address i, one presence test and at most one load per requested lane; Overlay/Base/Absent/Denied operands; populations as mask-risc AND/XOR/OR + Count programs; arms C (lazy/eager positional), B (connected delta, rank) and S (sparse, binary search). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- crates/lance-graph-mask-risc/Cargo.toml | 5 + .../examples/holo_thought_first_probe.rs | 1301 +++++++++++++++++ 2 files changed, 1306 insertions(+) create mode 100644 crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs diff --git a/crates/lance-graph-mask-risc/Cargo.toml b/crates/lance-graph-mask-risc/Cargo.toml index 1abcd91b5..e3b91bf65 100644 --- a/crates/lance-graph-mask-risc/Cargo.toml +++ b/crates/lance-graph-mask-risc/Cargo.toml @@ -51,3 +51,8 @@ test = true [[example]] name = "holo_lane_storage_probe" test = true + +# D-HOLO H14c (plan d-holo-h14c-thought-first-v1). +[[example]] +name = "holo_thought_first_probe" +test = true diff --git a/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs b/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs new file mode 100644 index 000000000..57cdd89dc --- /dev/null +++ b/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs @@ -0,0 +1,1301 @@ +//! D-HOLO H14c: thought-first positional reads, Hamming presence, memory. +//! +//! Pre-registered in `.claude/plans/d-holo-h14c-thought-first-v1.md` before +//! any run. The question is not how cheaply a layout rebuilds a row, but which +//! accesses remain once the thought, its operands and the Cartesian address +//! are known: +//! +//! ```text +//! Thought(t)[Table(a)[i] : Table(b)[i]] +//! ``` +//! +//! The thought's program selects lane tables `a`, `b` (handles resolved once, +//! never from the row); `i` addresses each of them directly; a presence bit +//! says whether a value is there, never where. Three paths are measured apart: +//! A point projection, B presence populations (mask-risc programs, no value +//! loads), C an explicit terminal row. +//! +//! Arms over one fixture: C (positional table per touched (thought, lane), +//! lazily zeroed or eagerly committed), B (connected delta: row index, lane +//! mask, packed lanes, rank), S (sparse: sorted addresses, binary search; the +//! one explicit address translation, priced for memory only). +//! +//! Run (release, the tier is printed): `cargo run --release --example +//! holo_thought_first_probe`. Oracle tests: `cargo test --release --example +//! holo_thought_first_probe`. Raw rows are printed as `csv,` lines. +#![allow(dead_code)] + +use std::hint::black_box; +use std::time::Instant; + +use lance_graph_mask_risc::{ + execute, MaskOp, Operand as MOp, Planes, Program, Scratch, Terminal, Value, +}; + +const N: usize = 65_536; +const WORDS: usize = N / 64; +const LANE: usize = 16; +const LANES: usize = 32; +const ROW: usize = LANES * LANE; +const NONE: u32 = u32::MAX; + +type Val = [u8; LANE]; + +fn tier() -> &'static str { + if cfg!(target_feature = "avx512f") { + "v4 (avx512f)" + } else if cfg!(target_feature = "avx2") { + "v3 (avx2): timings not reportable" + } else { + "below v3: timings not reportable" + } +} + +fn mix(mut z: u64) -> u64 { + z = z.wrapping_add(0x9E37_79B9_7F4A_7C15); + z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + z ^ (z >> 31) +} + +/// The value thought `t` writes into lane `l` at address `i`. Never all zero, +/// so an overlay of sixteen zero bytes only appears where a test puts it. +fn overlay_value(t: usize, l: usize, i: usize) -> Val { + let a = mix(((t as u64) << 48) ^ ((l as u64) << 32) ^ i as u64); + let b = mix(a ^ 0x5555); + let mut v = [0u8; LANE]; + v[..8].copy_from_slice(&a.to_le_bytes()); + v[8..].copy_from_slice(&b.to_le_bytes()); + v[0] |= 1; + v +} + +/// The immutable base: one 512-byte row per address (the given). +fn base_rows() -> Vec { + let mut b = vec![0u8; N * ROW]; + for (i, row) in b.chunks_exact_mut(ROW).enumerate() { + for l in 0..LANES { + let v = mix(0xBA5E ^ ((l as u64) << 32) ^ i as u64).to_le_bytes(); + row[l * LANE..l * LANE + 8].copy_from_slice(&v); + row[l * LANE + 8..(l + 1) * LANE].copy_from_slice(&v); + } + } + b +} + +fn base_lane(base: &[u8], i: usize, l: usize) -> Val { + base[i * ROW + l * LANE..i * ROW + (l + 1) * LANE] + .try_into() + .unwrap() +} + +#[inline] +fn bit(words: &[u64], i: usize) -> bool { + words[i / 64] >> (i % 64) & 1 == 1 +} + +// ------------------------------------------------------------- counters + +#[cfg(test)] +thread_local! { + /// Lane tables a read consulted (one per requested lane). + static CONSULTED: std::cell::Cell = const { std::cell::Cell::new(0) }; + /// Presence bits tested. + static PRESENCE: std::cell::Cell = const { std::cell::Cell::new(0) }; + /// 16-byte values loaded (overlay or base). + static LOADS: std::cell::Cell = const { std::cell::Cell::new(0) }; + /// Full rows built. + static ROWS: std::cell::Cell = const { std::cell::Cell::new(0) }; + /// Explicit address translations (arm S only). + static TRANSLATIONS: std::cell::Cell = const { std::cell::Cell::new(0) }; +} + +macro_rules! count { + ($c:ident) => { + #[cfg(test)] + $c.with(|c| c.set(c.get() + 1)); + }; +} + +#[cfg(test)] +fn counters() -> [u64; 5] { + [ + CONSULTED.with(|c| c.get()), + PRESENCE.with(|c| c.get()), + LOADS.with(|c| c.get()), + ROWS.with(|c| c.get()), + TRANSLATIONS.with(|c| c.get()), + ] +} + +#[cfg(test)] +fn reset() { + for c in [&CONSULTED, &PRESENCE, &LOADS, &ROWS, &TRANSLATIONS] { + c.with(|c| c.set(0)); + } +} + +// ------------------------------------------------------------- fixture + +/// Where dirty addresses fall. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Pattern { + /// Each address independently with probability `d`. + Uniform, + /// Runs of 64 consecutive addresses. + Clustered, + /// One contiguous range. + Contiguous, + /// Dense inside a few 256-address blocks (one Morton prefix cell each). + Morton, + /// Lanes of the touched set split the addresses between them. + Disjoint, + /// Every lane's set is the first lane's with 10 % of it changed. + Overlapping, +} + +impl Pattern { + fn name(self) -> &'static str { + match self { + Pattern::Uniform => "uniform", + Pattern::Clustered => "clustered", + Pattern::Contiguous => "contiguous", + Pattern::Morton => "morton", + Pattern::Disjoint => "disjoint", + Pattern::Overlapping => "overlapping", + } + } +} + +/// Dirty addresses of the `j`-th touched lane (of `u`) for thought `t`. +fn dirty_set(p: Pattern, d: f64, t: usize, j: usize, u: usize) -> Vec { + let seed = mix(((t as u64) << 20) ^ (j as u64) ^ 0xD1E7); + let thresh = (d * (u64::MAX as f64)) as u64; + let take = |i: usize, s: u64| d >= 1.0 || mix(s ^ i as u64) < thresh; + let mut v = Vec::new(); + match p { + Pattern::Uniform => { + for i in 0..N { + if take(i, seed) { + v.push(i as u32); + } + } + } + Pattern::Clustered => { + for b in 0..N / 64 { + if take(b, seed) { + v.extend((b * 64..b * 64 + 64).map(|i| i as u32)); + } + } + } + Pattern::Contiguous => { + let n = (d * N as f64).round() as usize; + let s = (seed as usize) % (N - n + 1); + v.extend((s..s + n).map(|i| i as u32)); + } + Pattern::Morton => { + // blocks of 256 addresses, half of each chosen block dirty + let blocks = ((d * N as f64) / 128.0).ceil() as usize; + let mut chosen: Vec = (0..N / 256).collect(); + chosen.sort_by_key(|&b| mix(seed ^ b as u64)); + chosen.truncate(blocks.min(N / 256)); + chosen.sort(); + for b in chosen { + for i in b * 256..b * 256 + 256 { + if mix(seed ^ 0xA ^ i as u64) & 1 == 0 { + v.push(i as u32); + } + } + } + } + Pattern::Disjoint => { + let common = mix(((t as u64) << 20) ^ 0xD15); + for i in 0..N { + if take(i, common) && (mix(common ^ 0xF00 ^ i as u64) as usize) % u == j { + v.push(i as u32); + } + } + } + Pattern::Overlapping => { + let first = mix(((t as u64) << 20) ^ 0xD1E7); + for i in 0..N { + let in_first = take(i, first); + let flip = j > 0 && mix(seed ^ 0xF1 ^ i as u64) < u64::MAX / 10 && take(i, seed); + if in_first ^ flip { + v.push(i as u32); + } + } + } + } + v +} + +/// Which lanes a thought touches: the first `u` of a fixed permutation of the +/// 32 lanes. A selection of `k` lanes takes the first `k` touched lanes. +fn touched_lanes(u: usize) -> Vec { + let mut all: Vec = (0..LANES).collect(); + all.sort_by_key(|&l| mix(0x7A11 ^ l as u64)); + all.truncate(u); + all +} + +/// One thought's writes: per touched lane its dirty addresses. +struct Writes { + thought: usize, + lanes: Vec<(usize, Vec)>, +} + +fn writes(p: Pattern, d: f64, t: usize, u: usize) -> Writes { + let lanes = touched_lanes(u); + Writes { + thought: t, + lanes: lanes + .iter() + .enumerate() + .map(|(j, &l)| (l, dirty_set(p, d, t, j, u))) + .collect(), + } +} + +// ------------------------------------------------------------- arm C + +/// How a positional table's pages are committed. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Commit { + /// Zeroed allocation: the OS commits a page on its first write. + Lazy, + /// Every page written at seal. + Eager, +} + +/// One (thought, lane) table: the value at address `i` is `values[i]`. +struct LaneTable { + present: Vec, + values: Vec, +} + +impl LaneTable { + fn seal(t: usize, l: usize, dirty: &[u32], commit: Commit) -> Self { + let mut values = vec![[0u8; LANE]; N]; + if commit == Commit::Eager { + // write one byte per page so every page is committed + for p in values.iter_mut().step_by(4096 / LANE) { + p[0] = black_box(0); + } + } + let mut present = vec![0u64; WORDS]; + for &i in dirty { + let i = i as usize; + present[i / 64] |= 1 << (i % 64); + values[i] = overlay_value(t, l, i); + } + LaneTable { present, values } + } +} + +/// Every touched table of one thought, indexed by lane (32 handles). +struct ThoughtC { + id: u16, + tables: Vec>, +} + +impl ThoughtC { + fn seal(w: &Writes, commit: Commit) -> Self { + let mut tables: Vec> = (0..LANES).map(|_| None).collect(); + for (l, dirty) in &w.lanes { + tables[*l] = Some(LaneTable::seal(w.thought, *l, dirty, commit)); + } + ThoughtC { + id: w.thought as u16, + tables, + } + } + + fn touched(&self) -> usize { + self.tables.iter().filter(|t| t.is_some()).count() + } +} + +/// What to return for a lane the thought has no value for at `i`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Fallback { + /// The immutable base value. + Base, + /// Nothing: report `Absent`. + Absent, +} + +/// A thought program's operand selection: which thought, which lanes. +#[derive(Clone, Debug)] +struct Selection { + thought: usize, + lanes: Vec, + fallback: Fallback, +} + +/// One operand of a point projection. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Got { + /// The thought wrote it; which thought is reported, so two thoughts' + /// evidence at one address stays apart. + Overlay { thought: u16, value: Val }, + /// Fallback to the immutable base. + Base(Val), + /// No overlay and no fallback. + Absent, + /// The aperture (authorization, time) excludes the address; nothing loaded. + Denied, +} + +/// A selection with its table handles resolved once: one handle per +/// requested lane, nothing else of the thought. +struct Resolved<'a> { + thought: u16, + slots: Vec<(usize, Option<&'a LaneTable>)>, + fallback: Fallback, + base: &'a [u8], +} + +fn resolve<'a>(sel: &Selection, thoughts: &'a [ThoughtC], base: &'a [u8]) -> Resolved<'a> { + let th = &thoughts[sel.thought]; + Resolved { + thought: th.id, + slots: sel + .lanes + .iter() + .map(|&l| (l, th.tables[l].as_ref())) + .collect(), + fallback: sel.fallback, + base, + } +} + +impl Resolved<'_> { + #[inline] + fn miss(&self, l: usize, i: usize) -> Got { + match self.fallback { + Fallback::Base => { + count!(LOADS); + Got::Base(base_lane(self.base, i, l)) + } + Fallback::Absent => Got::Absent, + } + } + + /// `Thought(t)[Table(a)[i] : Table(b)[i] : …]`: one presence test and at + /// most one load per requested lane, all at address `i`. + #[inline] + fn read(&self, i: usize, out: &mut [Got]) { + for (o, &(l, table)) in out.iter_mut().zip(&self.slots) { + count!(CONSULTED); + *o = match table { + Some(t) => { + count!(PRESENCE); + if bit(&t.present, i) { + count!(LOADS); + Got::Overlay { + thought: self.thought, + value: t.values[i], + } + } else { + self.miss(l, i) + } + } + None => self.miss(l, i), + }; + } + } + + /// The same read under an aperture (authorization and time composed into + /// one mask): a denied address loads nothing. + #[inline] + fn read_under(&self, aperture: &[u64], i: usize, out: &mut [Got]) { + if !bit(aperture, i) { + out.iter_mut().for_each(|o| *o = Got::Denied); + return; + } + self.read(i, out); + } +} + +/// The explicit terminal: one 512-byte row, base plus every overlay of the +/// thought. Only a named terminal calls this. +fn materialize_row(th: &ThoughtC, base: &[u8], i: usize) -> [u8; ROW] { + count!(ROWS); + let mut row: [u8; ROW] = base[i * ROW..(i + 1) * ROW].try_into().unwrap(); + for (l, t) in th.tables.iter().enumerate() { + if let Some(t) = t { + if bit(&t.present, i) { + row[l * LANE..(l + 1) * LANE].copy_from_slice(&t.values[i]); + } + } + } + row +} + +// ------------------------------------------------------------- arm B + +/// Connected delta: per dirty row one record (lane mask, changed lanes packed +/// in lane order), found through a positional row index. +struct ThoughtB { + id: u16, + rec_of: Vec, + masks: Vec, + offs: Vec, + vals: Vec, +} + +impl ThoughtB { + fn seal(w: &Writes) -> Self { + let mut row_mask = vec![0u32; N]; + for (l, dirty) in &w.lanes { + for &i in dirty { + row_mask[i as usize] |= 1 << l; + } + } + let mut b = ThoughtB { + id: w.thought as u16, + rec_of: vec![NONE; N], + masks: Vec::new(), + offs: Vec::new(), + vals: Vec::new(), + }; + for (i, &m) in row_mask.iter().enumerate() { + if m == 0 { + continue; + } + b.rec_of[i] = b.masks.len() as u32; + b.masks.push(m); + b.offs.push(b.vals.len() as u32); + let mut mm = m; + while mm != 0 { + let l = mm.trailing_zeros() as usize; + b.vals.push(overlay_value(w.thought, l, i)); + mm &= mm - 1; + } + } + b + } + + /// Lane `l` of row `i`: index lookup, mask test, popcount rank. + #[inline] + fn read(&self, sel_lanes: &[usize], fallback: Fallback, base: &[u8], i: usize, out: &mut [Got]) { + let r = self.rec_of[i]; + for (o, &l) in out.iter_mut().zip(sel_lanes) { + *o = if r != NONE && self.masks[r as usize] >> l & 1 == 1 { + let m = self.masks[r as usize]; + let rank = (m & ((1u32 << l) - 1)).count_ones(); + Got::Overlay { + thought: self.id, + value: self.vals[(self.offs[r as usize] + rank) as usize], + } + } else { + match fallback { + Fallback::Base => Got::Base(base_lane(base, i, l)), + Fallback::Absent => Got::Absent, + } + }; + } + } +} + +// ------------------------------------------------------------- arm S + +/// Sparse lane: dirty addresses sorted with their values. Lane `l` at `i` is +/// a binary search: an explicit address translation, priced, never direct. +struct SparseLane { + coords: Vec, + vals: Vec, +} + +struct ThoughtS { + id: u16, + lanes: Vec>, +} + +impl ThoughtS { + fn seal(w: &Writes) -> Self { + let mut lanes: Vec> = (0..LANES).map(|_| None).collect(); + for (l, dirty) in &w.lanes { + lanes[*l] = Some(SparseLane { + coords: dirty.clone(), + vals: dirty + .iter() + .map(|&i| overlay_value(w.thought, *l, i as usize)) + .collect(), + }); + } + ThoughtS { + id: w.thought as u16, + lanes, + } + } + + #[inline] + fn read(&self, sel_lanes: &[usize], fallback: Fallback, base: &[u8], i: usize, out: &mut [Got]) { + for (o, &l) in out.iter_mut().zip(sel_lanes) { + let hit = self.lanes[l].as_ref().and_then(|s| { + count!(TRANSLATIONS); + s.coords.binary_search(&(i as u32)).ok().map(|p| s.vals[p]) + }); + *o = match hit { + Some(value) => Got::Overlay { + thought: self.id, + value, + }, + None => match fallback { + Fallback::Base => Got::Base(base_lane(base, i, l)), + Fallback::Absent => Got::Absent, + }, + }; + } + } +} + +// ------------------------------------------------------------- populations + +/// `popcount(planes[0] & planes[1] & … )` through one mask-risc program. +fn and_count_program(n: u16) -> Program { + let mut ops = vec![MaskOp::And { + a: MOp::Plane(0), + b: MOp::Plane(1), + dst: 0, + }]; + for p in 2..n { + ops.push(MaskOp::And { + a: MOp::Scratch(0), + b: MOp::Plane(p), + dst: 0, + }); + } + Program::new( + ops, + Terminal::Count { + mask: MOp::Scratch(0), + }, + ) +} + +/// `popcount(planes[0] ^ planes[1])`: Hamming distance of two coverages. +fn xor_count_program() -> Program { + Program::new( + vec![MaskOp::Xor { + a: MOp::Plane(0), + b: MOp::Plane(1), + dst: 0, + }], + Terminal::Count { + mask: MOp::Scratch(0), + }, + ) +} + +/// `popcount(OR of n planes)`: the session-wide population. +fn or_count_program(n: u16) -> Program { + if n == 1 { + return Program::new(vec![], Terminal::Count { mask: MOp::Plane(0) }); + } + let mut ops = vec![MaskOp::Or { + a: MOp::Plane(0), + b: MOp::Plane(1), + dst: 0, + }]; + for p in 2..n { + ops.push(MaskOp::Or { + a: MOp::Scratch(0), + b: MOp::Plane(p), + dst: 0, + }); + } + Program::new( + ops, + Terminal::Count { + mask: MOp::Scratch(0), + }, + ) +} + +fn run_count(p: &Program, planes: &[&[u64]]) -> usize { + let pl = Planes { + n_rows: N, + masks: planes, + lanes: &[], + }; + let mut s = Scratch::for_program(p, N).expect("scratch"); + match execute(p, &pl, &mut s, None).expect("execute") { + Value::Count(c) => c, + v => panic!("not a count: {v:?}"), + } +} + +fn scalar_and(planes: &[&[u64]]) -> usize { + (0..N).filter(|&i| planes.iter().all(|p| bit(p, i))).count() +} + +fn scalar_xor(a: &[u64], b: &[u64]) -> usize { + (0..N).filter(|&i| bit(a, i) != bit(b, i)).count() +} + +// ------------------------------------------------------------- measurement + +fn proc_status(key: &str) -> u64 { + let s = std::fs::read_to_string("/proc/self/status").unwrap_or_default(); + s.lines() + .find(|l| l.starts_with(key)) + .and_then(|l| l.split_whitespace().nth(1)) + .and_then(|v| v.parse().ok()) + .unwrap_or(0) +} + +/// Minor page faults of this process so far (`/proc/self/stat` field 10). +fn minflt() -> u64 { + let s = std::fs::read_to_string("/proc/self/stat").unwrap_or_default(); + let after = s.rsplit(')').next().unwrap_or(""); + after + .split_whitespace() + .nth(7) + .and_then(|v| v.parse().ok()) + .unwrap_or(0) +} + +struct Mem { + vm_kb: u64, + rss_kb: u64, + flt: u64, +} + +fn mem() -> Mem { + Mem { + vm_kb: proc_status("VmSize:"), + rss_kb: proc_status("VmRSS:"), + flt: minflt(), + } +} + +/// Median of 7 batches, ns per op. +fn time_batches(ops_per_batch: usize, mut before: impl FnMut(), mut f: F) -> f64 { + let mut v = Vec::with_capacity(7); + f(); + for _ in 0..7 { + before(); + let t = Instant::now(); + f(); + v.push(t.elapsed().as_nanos() as f64 / ops_per_batch as f64); + } + v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v[3] +} + +/// Touch a 128 MiB buffer so the next batch starts cache-cold. +fn evict(buf: &mut [u64]) { + let mut s = 0u64; + for w in buf.iter_mut().step_by(8) { + *w = w.wrapping_add(1); + s = s.wrapping_add(*w); + } + black_box(s); +} + +fn csv(fields: &[String]) { + println!("csv,{}", fields.join(",")); +} + +const READS: usize = 8_192; + +fn addrs_hot() -> Vec { + let set: Vec = (0..256).map(|j| (mix(0x407 ^ j) as usize) % N).collect(); + (0..READS).map(|j| set[j % 256]).collect() +} + +fn addrs_cold() -> Vec { + (0..READS).map(|j| (mix(0xC01D ^ j as u64) as usize) % N).collect() +} + +fn main() { + let args: Vec = std::env::args().collect(); + let only = args.get(1).map(String::as_str).unwrap_or("all"); + println!("tier: {}", tier()); + println!( + "host: MemTotal {} kB, batches 7 (median), reads per batch {READS}", + proc_status_global("MemTotal:") + ); + println!("csv,section,arm,pattern,density,T,U,k,cache,metric,value"); + let base = base_rows(); + let mut evict_buf = vec![0u64; 128 << 20 >> 3]; + if only == "all" || only == "main" { + main_grid(&base, &mut evict_buf); + } + if only == "all" || only == "thoughts" { + thought_axis(&base, &mut evict_buf); + } + if only == "all" || only == "spatial" { + spatial_axis(&base, &mut evict_buf); + } + if only == "all" || only == "memory" { + memory_grid(); + } +} + +fn proc_status_global(key: &str) -> u64 { + let s = std::fs::read_to_string("/proc/meminfo").unwrap_or_default(); + s.lines() + .find(|l| l.starts_with(key)) + .and_then(|l| l.split_whitespace().nth(1)) + .and_then(|v| v.parse().ok()) + .unwrap_or(0) +} + +const DENSITIES: [f64; 6] = [0.0, 0.001, 0.01, 0.1, 0.5, 1.0]; +const KS: [usize; 6] = [1, 2, 4, 8, 16, 31]; + +#[allow(clippy::too_many_arguments)] +fn row( + section: &str, + arm: &str, + p: Pattern, + d: f64, + t: usize, + u: usize, + k: usize, + cache: &str, + metric: &str, + value: f64, +) { + csv(&[ + section.into(), + arm.into(), + p.name().into(), + format!("{d}"), + t.to_string(), + u.to_string(), + k.to_string(), + cache.into(), + metric.into(), + format!("{value:.3}"), + ]); +} + +/// Point projection (A), populations (B) and the terminal (C) over one +/// thought, uniform addresses, every (density, U, k). +fn main_grid(base: &[u8], ev: &mut [u64]) { + let hot = addrs_hot(); + let cold = addrs_cold(); + for &d in &DENSITIES { + for &u in &[1usize, 2, 4, 8, 16, 31] { + // U is crossed at {k, 8, 31} with U >= k + let ks: Vec = KS + .iter() + .copied() + .filter(|&k| k <= u && (u == k || u == 8 || u == 31)) + .collect(); + let w = writes(Pattern::Uniform, d, 0, u); + let c = vec![ThoughtC::seal(&w, Commit::Lazy)]; + let b = ThoughtB::seal(&w); + let s = ThoughtS::seal(&w); + for &k in &ks { + let lanes = touched_lanes(u)[..k].to_vec(); + let sel = Selection { + thought: 0, + lanes: lanes.clone(), + fallback: Fallback::Base, + }; + let res_ns = { + let t = Instant::now(); + for _ in 0..1000 { + black_box(resolve(black_box(&sel), &c, base)); + } + t.elapsed().as_nanos() as f64 / 1000.0 + }; + row("A", "C", Pattern::Uniform, d, 1, u, k, "-", "resolve_ns", res_ns); + let r = resolve(&sel, &c, base); + let mut out = vec![Got::Absent; k]; + for (cache, addrs) in [("hot", &hot), ("cold", &cold)] { + let cold_run = cache == "cold"; + let ns_c = time_batches( + READS, + || { + if cold_run { + evict(ev) + } + }, + || { + for &i in addrs.iter() { + r.read(black_box(i), &mut out); + black_box(&out); + } + }, + ); + let ns_b = time_batches( + READS, + || { + if cold_run { + evict(ev) + } + }, + || { + for &i in addrs.iter() { + b.read(&lanes, Fallback::Base, base, black_box(i), &mut out); + black_box(&out); + } + }, + ); + let ns_s = time_batches( + READS, + || { + if cold_run { + evict(ev) + } + }, + || { + for &i in addrs.iter() { + s.read(&lanes, Fallback::Base, base, black_box(i), &mut out); + black_box(&out); + } + }, + ); + row("A", "C", Pattern::Uniform, d, 1, u, k, cache, "read_ns", ns_c); + row("A", "B", Pattern::Uniform, d, 1, u, k, cache, "read_ns", ns_b); + row("A", "S", Pattern::Uniform, d, 1, u, k, cache, "read_ns", ns_s); + } + } + if u >= 2 { + // populations over the first two touched tables, aperture = all + let l = touched_lanes(u); + let pa = &c[0].tables[l[0]].as_ref().unwrap().present; + let pb = &c[0].tables[l[1]].as_ref().unwrap().present; + let ap = vec![u64::MAX; WORDS]; + let and3 = and_count_program(3); + let xor = xor_count_program(); + let planes3: [&[u64]; 3] = [pa, pb, &ap]; + let planes2: [&[u64]; 2] = [pa, pb]; + let ns_and = time_batches(WORDS, || {}, || { + black_box(run_count(&and3, black_box(&planes3))); + }); + let ns_xor = time_batches(WORDS, || {}, || { + black_box(run_count(&xor, black_box(&planes2))); + }); + row("B", "C", Pattern::Uniform, d, 1, u, 2, "hot", "shared_ns_per_word", ns_and); + row("B", "C", Pattern::Uniform, d, 1, u, 2, "hot", "hamming_ns_per_word", ns_xor); + row( + "B", + "C", + Pattern::Uniform, + d, + 1, + u, + 2, + "-", + "shared_count", + run_count(&and3, &planes3) as f64, + ); + } + if u == 31 { + // explicit terminal: rows built for 1,024 addresses + let addrs: Vec = (0..1024).map(|j| (mix(0x7E ^ j) as usize) % N).collect(); + let ns = time_batches(1024, || {}, || { + for &i in &addrs { + black_box(materialize_row(&c[0], base, black_box(i))); + } + }); + row("C", "C", Pattern::Uniform, d, 1, u, 31, "hot", "row_ns", ns); + } + } + } +} + +/// Point reads across thoughts and the session OR, at k = 2, U = 31. +fn thought_axis(base: &[u8], ev: &mut [u64]) { + for &d in &[0.01, 0.1] { + for &tn in &[1usize, 8, 64] { + let cs: Vec = (0..tn) + .map(|t| ThoughtC::seal(&writes(Pattern::Uniform, d, t, 31), Commit::Lazy)) + .collect(); + let lanes = touched_lanes(31)[..2].to_vec(); + let resolved: Vec = (0..tn) + .map(|t| { + resolve( + &Selection { + thought: t, + lanes: lanes.clone(), + fallback: Fallback::Base, + }, + &cs, + base, + ) + }) + .collect(); + let pairs: Vec<(usize, usize)> = (0..READS) + .map(|j| { + let z = mix(0x7407 ^ j as u64); + ((z as usize) % tn, ((z >> 32) as usize) % N) + }) + .collect(); + let mut out = vec![Got::Absent; 2]; + for cache in ["hot", "cold"] { + let cold_run = cache == "cold"; + let ns = time_batches( + READS, + || { + if cold_run { + evict(ev) + } + }, + || { + for &(t, i) in &pairs { + resolved[t].read(black_box(i), &mut out); + black_box(&out); + } + }, + ); + row("A", "C", Pattern::Uniform, d, tn, 31, 2, cache, "read_ns", ns); + } + let l0 = lanes[0]; + let planes: Vec<&[u64]> = cs + .iter() + .map(|c| c.tables[l0].as_ref().unwrap().present.as_slice()) + .collect(); + let prog = or_count_program(tn as u16); + let ns = time_batches(WORDS, || {}, || { + black_box(run_count(&prog, black_box(&planes))); + }); + row("B", "C", Pattern::Uniform, d, tn, 31, 1, "hot", "session_or_ns_per_word", ns); + } + } +} + +/// k = 2, U = 31, one thought, every spatial pattern. +fn spatial_axis(base: &[u8], ev: &mut [u64]) { + let hot = addrs_hot(); + let cold = addrs_cold(); + for &d in &[0.01, 0.1] { + for p in [ + Pattern::Uniform, + Pattern::Clustered, + Pattern::Contiguous, + Pattern::Morton, + Pattern::Disjoint, + Pattern::Overlapping, + ] { + let w = writes(p, d, 0, 31); + let c = vec![ThoughtC::seal(&w, Commit::Lazy)]; + let b = ThoughtB::seal(&w); + let lanes = touched_lanes(31)[..2].to_vec(); + let r = resolve( + &Selection { + thought: 0, + lanes: lanes.clone(), + fallback: Fallback::Base, + }, + &c, + base, + ); + let mut out = vec![Got::Absent; 2]; + for (cache, addrs) in [("hot", &hot), ("cold", &cold)] { + let cold_run = cache == "cold"; + let ns_c = time_batches( + READS, + || { + if cold_run { + evict(ev) + } + }, + || { + for &i in addrs.iter() { + r.read(black_box(i), &mut out); + black_box(&out); + } + }, + ); + let ns_b = time_batches( + READS, + || { + if cold_run { + evict(ev) + } + }, + || { + for &i in addrs.iter() { + b.read(&lanes, Fallback::Base, base, black_box(i), &mut out); + black_box(&out); + } + }, + ); + row("A", "C", p, d, 1, 31, 2, cache, "read_ns", ns_c); + row("A", "B", p, d, 1, 31, 2, cache, "read_ns", ns_b); + } + let pa = &c[0].tables[lanes[0]].as_ref().unwrap().present; + let pb = &c[0].tables[lanes[1]].as_ref().unwrap().present; + let planes2: [&[u64]; 2] = [pa, pb]; + let ap = vec![u64::MAX; WORDS]; + let planes3: [&[u64]; 3] = [pa, pb, &ap]; + row("B", "C", p, d, 1, 31, 2, "-", "shared_count", run_count(&and_count_program(3), &planes3) as f64); + row("B", "C", p, d, 1, 31, 2, "-", "hamming", run_count(&xor_count_program(), &planes2) as f64); + row("B", "C", p, d, 1, 31, 2, "-", "pop_a", run_count(&or_count_program(1), &[pa.as_slice()]) as f64); + } + } +} + +/// Resident cost of C-lazy, C-eager and S, per (T, density, pattern), U = 31. +fn memory_grid() { + for p in [Pattern::Uniform, Pattern::Clustered] { + for &d in &[0.001, 0.01, 0.1, 1.0] { + for &tn in &[1usize, 8, 64] { + let ws: Vec = (0..tn).map(|t| writes(p, d, t, 31)).collect(); + let dirty: usize = ws.iter().map(|w| w.lanes.iter().map(|(_, v)| v.len()).sum::()).sum(); + let tables = tn * 31; + row("M", "-", p, d, tn, 31, 0, "-", "logical_bytes", (tables * N * LANE) as f64); + row("M", "-", p, d, tn, 31, 0, "-", "payload_bytes", (dirty * LANE) as f64); + row("M", "-", p, d, tn, 31, 0, "-", "presence_bytes", (tables * WORDS * 8) as f64); + row("M", "-", p, d, tn, 31, 0, "-", "sparse_persist_bytes", (dirty * (4 + LANE)) as f64); + for (arm, commit) in [("C-lazy", Some(Commit::Lazy)), ("C-eager", Some(Commit::Eager)), ("S", None)] { + let m0 = mem(); + let t = Instant::now(); + let held: (Vec, Vec) = match commit { + Some(c) => (ws.iter().map(|w| ThoughtC::seal(w, c)).collect(), vec![]), + None => (vec![], ws.iter().map(ThoughtS::seal).collect()), + }; + let seal_ns = t.elapsed().as_nanos() as f64; + let m1 = mem(); + black_box(&held); + row("M", arm, p, d, tn, 31, 0, "-", "virtual_delta_bytes", ((m1.vm_kb as f64 - m0.vm_kb as f64) * 1024.0).max(0.0)); + row("M", arm, p, d, tn, 31, 0, "-", "rss_delta_bytes", ((m1.rss_kb as f64 - m0.rss_kb as f64) * 1024.0).max(0.0)); + row("M", arm, p, d, tn, 31, 0, "-", "minor_faults", (m1.flt - m0.flt) as f64); + row("M", arm, p, d, tn, 31, 0, "-", "seal_ns_per_dirty", if dirty > 0 { seal_ns / dirty as f64 } else { seal_ns }); + drop(held); + } + } + } + } +} + +// ------------------------------------------------------------- oracle tests + +#[cfg(test)] +mod tests { + use super::*; + + /// A small fixture: thought 0 touches 31 lanes, uniform 10 %. + fn fixture(u: usize) -> (Vec, Writes, Vec) { + let base = base_rows(); + let w = writes(Pattern::Uniform, 0.1, 0, u); + let c = vec![ThoughtC::seal(&w, Commit::Lazy)]; + (base, w, c) + } + + fn reference(w: &Writes, base: &[u8], l: usize, i: usize, fb: Fallback) -> Got { + for (ll, dirty) in &w.lanes { + if *ll == l && dirty.binary_search(&(i as u32)).is_ok() { + return Got::Overlay { + thought: w.thought as u16, + value: overlay_value(w.thought, l, i), + }; + } + } + match fb { + Fallback::Base => Got::Base(base_lane(base, i, l)), + Fallback::Absent => Got::Absent, + } + } + + /// Oracles 1 and 2: every selected lane at every address equals the + /// reference, on C, B and S. + #[test] + fn every_arm_reads_the_reference_at_every_address() { + let (base, w, c) = fixture(31); + let b = ThoughtB::seal(&w); + let s = ThoughtS::seal(&w); + let lanes = touched_lanes(31)[..4].to_vec(); + for fb in [Fallback::Base, Fallback::Absent] { + let r = resolve(&Selection { thought: 0, lanes: lanes.clone(), fallback: fb }, &c, &base); + let mut oc = vec![Got::Absent; 4]; + let mut ob = vec![Got::Absent; 4]; + let mut os = vec![Got::Absent; 4]; + for i in 0..N { + r.read(i, &mut oc); + b.read(&lanes, fb, &base, i, &mut ob); + s.read(&lanes, fb, &base, i, &mut os); + for (j, &l) in lanes.iter().enumerate() { + let want = reference(&w, &base, l, i, fb); + assert_eq!(oc[j], want, "C lane {l} at {i}"); + assert_eq!(ob[j], want, "B lane {l} at {i}"); + assert_eq!(os[j], want, "S lane {l} at {i}"); + } + } + } + } + + /// Oracle 5 (and the core falsifier): a read consults exactly the + /// requested tables, whatever the thought touched. + #[test] + fn tables_consulted_equal_requested_lanes_for_every_touched_count() { + let base = base_rows(); + for u in [2usize, 8, 31] { + let w = writes(Pattern::Uniform, 0.1, 0, u); + let c = vec![ThoughtC::seal(&w, Commit::Lazy)]; + assert_eq!(c[0].touched(), u, "the fixture must touch {u} tables"); + let lanes = touched_lanes(u)[..2].to_vec(); + let r = resolve(&Selection { thought: 0, lanes, fallback: Fallback::Absent }, &c, &base); + let mut out = vec![Got::Absent; 2]; + reset(); + for i in 0..1000 { + r.read(i, &mut out); + } + let [consulted, presence, _, rows, tr] = counters(); + assert_eq!(consulted, 2 * 1000, "U = {u}"); + assert_eq!(presence, 2 * 1000, "U = {u}"); + assert_eq!(rows, 0); + assert_eq!(tr, 0); + } + } + + /// Oracle 3: an overlay of sixteen zero bytes is not `Absent`. + #[test] + fn a_zero_overlay_is_not_absent() { + let base = base_rows(); + let l = touched_lanes(1)[0]; + let w = Writes { thought: 0, lanes: vec![(l, vec![5])] }; + let mut c = vec![ThoughtC::seal(&w, Commit::Lazy)]; + c[0].tables[l].as_mut().unwrap().values[5] = [0; LANE]; + let r = resolve(&Selection { thought: 0, lanes: vec![l], fallback: Fallback::Absent }, &c, &base); + let mut out = [Got::Absent]; + r.read(5, &mut out); + assert_eq!(out[0], Got::Overlay { thought: 0, value: [0; LANE] }); + r.read(6, &mut out); + assert_eq!(out[0], Got::Absent); + } + + /// Oracle 4: overlay beats base; base only when the selection asks. + #[test] + fn overlay_precedes_base_and_fallback_is_explicit() { + let (base, w, c) = fixture(4); + let l = touched_lanes(4)[0]; + let dirty = &w.lanes[0].1; + let hit = dirty[0] as usize; + let miss = (0..N).find(|i| dirty.binary_search(&(*i as u32)).is_err()).unwrap(); + let mut out = [Got::Absent]; + let rb = resolve(&Selection { thought: 0, lanes: vec![l], fallback: Fallback::Base }, &c, &base); + rb.read(hit, &mut out); + assert!(matches!(out[0], Got::Overlay { .. })); + rb.read(miss, &mut out); + assert_eq!(out[0], Got::Base(base_lane(&base, miss, l))); + let ra = resolve(&Selection { thought: 0, lanes: vec![l], fallback: Fallback::Absent }, &c, &base); + ra.read(miss, &mut out); + assert_eq!(out[0], Got::Absent); + } + + /// Oracles 6 and 7: mask-risc populations equal a scalar bit loop. + #[test] + fn populations_equal_the_scalar_reference() { + for p in [Pattern::Uniform, Pattern::Clustered, Pattern::Disjoint, Pattern::Overlapping] { + let w = writes(p, 0.1, 0, 4); + let c = ThoughtC::seal(&w, Commit::Lazy); + let l = touched_lanes(4); + let pa = &c.tables[l[0]].as_ref().unwrap().present; + let pb = &c.tables[l[1]].as_ref().unwrap().present; + let ap: Vec = (0..WORDS).map(|j| mix(0xA9 ^ j as u64)).collect(); + let three: [&[u64]; 3] = [pa, pb, &ap]; + assert_eq!(run_count(&and_count_program(3), &three), scalar_and(&three), "{p:?}"); + let two: [&[u64]; 2] = [pa, pb]; + assert_eq!(run_count(&xor_count_program(), &two), scalar_xor(pa, pb), "{p:?}"); + let or = (0..N).filter(|&i| bit(pa, i) || bit(pb, i)).count(); + assert_eq!(run_count(&or_count_program(2), &two), or, "{p:?}"); + // weight of one plane equals its dirty count + assert_eq!(run_count(&or_count_program(1), &[pa.as_slice()]), w.lanes[0].1.len()); + } + // the disjoint pattern really is disjoint, the overlapping one overlaps + let wd = writes(Pattern::Disjoint, 0.5, 0, 4); + let cd = ThoughtC::seal(&wd, Commit::Lazy); + let l = touched_lanes(4); + let (a, b) = (&cd.tables[l[0]].as_ref().unwrap().present, &cd.tables[l[1]].as_ref().unwrap().present); + assert_eq!(scalar_and(&[a.as_slice(), b.as_slice()]), 0); + assert!(scalar_xor(a, b) > 0); + } + + /// Oracle 6 (C path): a population query loads no value. + #[test] + fn a_population_query_loads_no_value() { + let (_, _, c) = fixture(4); + let l = touched_lanes(4); + let pa = &c[0].tables[l[0]].as_ref().unwrap().present; + let pb = &c[0].tables[l[1]].as_ref().unwrap().present; + reset(); + black_box(run_count(&and_count_program(2), &[pa.as_slice(), pb.as_slice()])); + assert_eq!(counters(), [0; 5]); + } + + /// Oracle 11: point reads build no row; the terminal builds exactly the + /// rows asked for, and equals base plus every overlay. + #[test] + fn rows_are_built_only_by_the_terminal() { + let (base, w, c) = fixture(31); + let r = resolve(&Selection { thought: 0, lanes: touched_lanes(31)[..2].to_vec(), fallback: Fallback::Base }, &c, &base); + let mut out = vec![Got::Absent; 2]; + reset(); + for i in 0..4096 { + r.read(i, &mut out); + } + assert_eq!(counters()[3], 0); + for i in 0..7 { + let row = materialize_row(&c[0], &base, i); + for l in 0..LANES { + let want = match reference(&w, &base, l, i, Fallback::Base) { + Got::Overlay { value, .. } | Got::Base(value) => value, + _ => unreachable!(), + }; + assert_eq!(&row[l * LANE..(l + 1) * LANE], &want); + } + } + assert_eq!(counters()[3], 7); + } + + /// Oracle 12: two thoughts at one coordinate keep their own values. + #[test] + fn two_thoughts_at_one_coordinate_stay_apart() { + let base = base_rows(); + let l = touched_lanes(1)[0]; + let c: Vec = (0..2) + .map(|t| ThoughtC::seal(&Writes { thought: t, lanes: vec![(l, vec![9])] }, Commit::Lazy)) + .collect(); + let mut out = [Got::Absent]; + for t in 0..2 { + resolve(&Selection { thought: t, lanes: vec![l], fallback: Fallback::Absent }, &c, &base).read(9, &mut out); + assert_eq!(out[0], Got::Overlay { thought: t as u16, value: overlay_value(t, l, 9) }); + } + assert_ne!(overlay_value(0, l, 9), overlay_value(1, l, 9)); + } + + /// Oracle 13: a denied address loads nothing. + #[test] + fn a_denied_address_loads_nothing() { + let (base, _, c) = fixture(4); + let r = resolve(&Selection { thought: 0, lanes: touched_lanes(4)[..2].to_vec(), fallback: Fallback::Base }, &c, &base); + let mut ap = vec![0u64; WORDS]; + ap[0] = 1; // only address 0 admitted + let mut out = vec![Got::Absent; 2]; + reset(); + r.read_under(&ap, 1, &mut out); + assert_eq!(out, vec![Got::Denied; 2]); + assert_eq!(counters()[2], 0, "no value may be loaded for a denied address"); + r.read_under(&ap, 0, &mut out); + assert!(out.iter().all(|g| !matches!(g, Got::Denied))); + } + + /// The fixtures do what their names say (anti-vacuity). + #[test] + fn fixtures_have_the_stated_shape() { + let u = writes(Pattern::Uniform, 0.01, 0, 2); + let n = u.lanes[0].1.len(); + assert!((400..900).contains(&n), "uniform 1 % of 65,536: {n}"); + let cl = writes(Pattern::Clustered, 0.01, 0, 2); + assert!(cl.lanes[0].1.chunks(64).all(|r| r[63] - r[0] == 63)); + let ct = writes(Pattern::Contiguous, 0.01, 0, 2); + let v = &ct.lanes[0].1; + assert_eq!(v.len(), 655); + assert_eq!(v[v.len() - 1] - v[0], 654); + let mo = writes(Pattern::Morton, 0.01, 0, 2); + let blocks: std::collections::BTreeSet = mo.lanes[0].1.iter().map(|i| i / 256).collect(); + assert!(blocks.len() <= 6, "morton: {} blocks", blocks.len()); + assert_eq!(writes(Pattern::Uniform, 0.0, 0, 2).lanes[0].1.len(), 0); + assert_eq!(writes(Pattern::Uniform, 1.0, 0, 2).lanes[0].1.len(), N); + } +} From f9474e4acd5fe93e2d65f451b4de18b86b8aa689 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 22:57:19 +0000 Subject: [PATCH 3/9] D-HOLO H14c: lane_footprint instrument (planes and lanes a mask-risc program names), test Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .../examples/holo_thought_first_probe.rs | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs b/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs index 57cdd89dc..09221874a 100644 --- a/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs +++ b/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs @@ -636,6 +636,26 @@ fn scalar_xor(a: &[u64], b: &[u64]) -> usize { (0..N).filter(|&i| bit(a, i) != bit(b, i)).count() } +/// The planes and value lanes a mask-risc program names (D-HOLO-H14c-6): +/// the operand selection the program carries, read from the program itself. +/// Parsed from the program's `Debug` form (`Plane(n)`, `lane: n`) so it +/// covers every op and terminal variant without restating them; a lane field +/// that is not a literal is not counted. +fn lane_footprint(p: &Program) -> (std::collections::BTreeSet, std::collections::BTreeSet) { + let text = format!("{p:?}"); + let grab = |key: &str, end: char| { + text.match_indices(key) + .filter_map(|(i, _)| { + let rest = &text[i + key.len()..]; + let num: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect(); + let ok = rest[num.len()..].starts_with(end) || end == ' '; + (ok && !num.is_empty()).then(|| num.parse().ok()).flatten() + }) + .collect::>() + }; + (grab("Plane(", ')'), grab("lane: ", ' ')) +} + // ------------------------------------------------------------- measurement fn proc_status(key: &str) -> u64 { @@ -1280,6 +1300,25 @@ mod tests { assert!(out.iter().all(|g| !matches!(g, Got::Denied))); } + /// The footprint instrument reads exactly the planes and lanes named. + #[test] + fn lane_footprint_reads_the_program_selection() { + let (planes, lanes) = lane_footprint(&and_count_program(3)); + assert_eq!(planes.into_iter().collect::>(), vec![0, 1, 2]); + assert!(lanes.is_empty()); + let p = Program::new( + vec![lance_graph_mask_risc::MaskOp::Pred { + pred: lance_graph_mask_risc::Pred::GtI32 { lane: 7, t: 3 }, + under: Some(MOp::Plane(4)), + dst: 0, + }], + Terminal::MaskedSumI32 { mask: MOp::Scratch(0), lane: 12 }, + ); + let (planes, lanes) = lane_footprint(&p); + assert_eq!(planes.into_iter().collect::>(), vec![4]); + assert_eq!(lanes.into_iter().collect::>(), vec![7, 12]); + } + /// The fixtures do what their names say (anti-vacuity). #[test] fn fixtures_have_the_stated_shape() { From 306975f5b32183eab0c36b188781224ff0772db5 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 22:57:35 +0000 Subject: [PATCH 4/9] D-HOLO H14c: Lance 13 masked-I/O and coordinate-identity probe crate (excluded from the workspace; first build in progress, tests not yet run) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- Cargo.toml | 2 + crates/holo-lance-masked-io-probe/Cargo.toml | 19 + crates/holo-lance-masked-io-probe/src/main.rs | 581 ++++++++++++++++++ 3 files changed, 602 insertions(+) create mode 100644 crates/holo-lance-masked-io-probe/Cargo.toml create mode 100644 crates/holo-lance-masked-io-probe/src/main.rs diff --git a/Cargo.toml b/Cargo.toml index 22d085929..1444afd52 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -41,6 +41,8 @@ members = [ ] exclude = [ "crates/lance-graph-sap", + # D-HOLO-H14c Lance 13 masked-I/O probe: own narrow dependency set. + "crates/holo-lance-masked-io-probe", "crates/lance-graph-glove-parity", # Python bindings (upstream-inherited, opt-in via --manifest-path) "crates/lance-graph-python", diff --git a/crates/holo-lance-masked-io-probe/Cargo.toml b/crates/holo-lance-masked-io-probe/Cargo.toml new file mode 100644 index 000000000..b3faa0367 --- /dev/null +++ b/crates/holo-lance-masked-io-probe/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "holo-lance-masked-io-probe" +version = "0.1.0" +edition = "2021" +publish = false +description = "D-HOLO-H14c-4/-5: Lance 13 masked I/O and coordinate identity probe (plan d-holo-h14c-thought-first-v1)" + +# Excluded from the workspace on purpose: a research probe with its own narrow +# dependency set (lance, arrow, tokio), so it changes no dependency of any +# workspace crate. Run with +# cargo run --release --manifest-path crates/holo-lance-masked-io-probe/Cargo.toml +# cargo test --release --manifest-path crates/holo-lance-masked-io-probe/Cargo.toml +[dependencies] +lance = { version = "13.*", default-features = false } +arrow-array = "58" +arrow-schema = "58" +futures = "0.3" +tokio = { version = "1.37", features = ["macros", "rt-multi-thread"] } +tempfile = "3" diff --git a/crates/holo-lance-masked-io-probe/src/main.rs b/crates/holo-lance-masked-io-probe/src/main.rs new file mode 100644 index 000000000..212de8c66 --- /dev/null +++ b/crates/holo-lance-masked-io-probe/src/main.rs @@ -0,0 +1,581 @@ +//! D-HOLO H14c-4 and -5: Lance 13 masked I/O and coordinate identity. +//! +//! Pre-registered in `.claude/plans/d-holo-h14c-thought-first-v1.md` (§ 7, § 8) +//! before any run. +//! +//! One Lance dataset per tile: an explicit `coord: u32` column (the Cartesian +//! address, the logical identity), an `epoch: u32` column (rewritten by +//! updates), and `LANES` lane columns `FixedSizeBinary(16)`, nullable (null = +//! absent). A [`CoordMap`] translates coordinates into the dataset's `_rowid` +//! space at one named version; a masked read refuses any other version +//! ([`ReadError::StaleMapping`]). Values are attributed by their stored +//! `coord`, never by output position. +//! +//! Strategies measured: unmasked projection (the I/O baseline); combined +//! (one mask = rows where every requested lane is present, one projection); +//! independent (one masked read per lane with that lane's own mask, aligned +//! by `coord`). Counters come from `Scanner::scan_stats_callback` +//! (`ExecutionSummaryCounts`). +//! +//! Run: `cargo run --release --manifest-path +//! crates/holo-lance-masked-io-probe/Cargo.toml`. Tests: `cargo test --release +//! --manifest-path crates/holo-lance-masked-io-probe/Cargo.toml`. + +use std::collections::BTreeMap; +use std::sync::{Arc, Mutex}; +use std::time::Instant; + +use arrow_array::builder::FixedSizeBinaryBuilder; +use arrow_array::{ + Array, FixedSizeBinaryArray, RecordBatch, RecordBatchIterator, UInt32Array, UInt64Array, +}; +use arrow_schema::{DataType, Field, Schema}; +use lance::dataset::scanner::{MaterializationStyle, RowAddrMask, RowAddrTreeMap}; +use lance::dataset::{Dataset, WriteMode, WriteParams}; + +const LANE: usize = 16; +/// Lane columns in the fixture (the grid goes to k = 8). +const LANES: usize = 8; +const N: u32 = 65_536; + +type Val = [u8; LANE]; + +fn mix(mut z: u64) -> u64 { + z = z.wrapping_add(0x9E37_79B9_7F4A_7C15); + z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9); + z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB); + z ^ (z >> 31) +} + +fn lane_name(l: usize) -> String { + format!("lane_{l}") +} + +/// The value of lane `l` at coordinate `c` in a given epoch (never all zero). +fn value(l: usize, c: u32, epoch: u32) -> Val { + let a = mix(((l as u64) << 40) ^ ((epoch as u64) << 32) ^ c as u64); + let b = mix(a ^ 0x77); + let mut v = [0u8; LANE]; + v[..8].copy_from_slice(&a.to_le_bytes()); + v[8..].copy_from_slice(&b.to_le_bytes()); + v[0] |= 1; + v +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Pattern { + Uniform, + Clustered, +} + +impl Pattern { + fn name(self) -> &'static str { + match self { + Pattern::Uniform => "uniform", + Pattern::Clustered => "clustered", + } + } +} + +/// Whether lane `l` holds a value at coordinate `c` (independent per lane). +fn present(p: Pattern, d: f64, l: usize, c: u32) -> bool { + if d >= 1.0 { + return true; + } + let t = (d * u64::MAX as f64) as u64; + match p { + Pattern::Uniform => mix(0x1A9E ^ ((l as u64) << 40) ^ c as u64) < t, + Pattern::Clustered => mix(0xC1u64 ^ ((l as u64) << 40) ^ (c / 64) as u64) < t, + } +} + +fn schema() -> Arc { + let mut f = vec![ + Field::new("coord", DataType::UInt32, false), + Field::new("epoch", DataType::UInt32, false), + ]; + for l in 0..LANES { + f.push(Field::new(lane_name(l), DataType::FixedSizeBinary(LANE as i32), true)); + } + Arc::new(Schema::new(f)) +} + +/// Rows for the given coordinates, in the given order. +fn batch(coords: &[u32], p: Pattern, d: f64, epoch: u32) -> RecordBatch { + let mut cols: Vec> = vec![ + Arc::new(UInt32Array::from(coords.to_vec())), + Arc::new(UInt32Array::from(vec![epoch; coords.len()])), + ]; + for l in 0..LANES { + let mut b = FixedSizeBinaryBuilder::with_capacity(coords.len(), LANE as i32); + for &c in coords { + if present(p, d, l, c) { + b.append_value(value(l, c, epoch)).unwrap(); + } else { + b.append_null(); + } + } + cols.push(Arc::new(b.finish())); + } + RecordBatch::try_new(schema(), cols).unwrap() +} + +async fn write( + uri: &str, + batches: Vec, + mode: WriteMode, + stable: bool, + rows_per_file: usize, +) -> Dataset { + let reader = RecordBatchIterator::new(batches.into_iter().map(Ok), schema()); + let params = WriteParams { + mode, + enable_stable_row_ids: stable, + max_rows_per_file: rows_per_file, + ..Default::default() + }; + Dataset::write(reader, uri, Some(params)).await.unwrap() +} + +// ------------------------------------------------------------- identity + +/// Coordinate -> `_rowid` at one dataset version. Valid only for that version. +#[derive(Clone, Debug)] +struct CoordMap { + version: u64, + id_of: BTreeMap, +} + +#[derive(Debug, PartialEq, Eq)] +enum ReadError { + /// The map was built at another dataset version. + StaleMapping { map: u64, dataset: u64 }, + /// Lance refused the read (missing column, missing dataset, …). + Lance(String), +} + +async fn build_map(ds: &Dataset) -> CoordMap { + let mut s = ds.scan(); + s.project(&["coord"]).unwrap(); + s.with_row_id(); + let b = s.try_into_batch().await.unwrap(); + let coord = b + .column_by_name("coord") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let id = b + .column_by_name("_rowid") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let mut id_of = BTreeMap::new(); + for j in 0..b.num_rows() { + let prev = id_of.insert(coord.value(j), id.value(j)); + assert!(prev.is_none(), "coord {} twice", coord.value(j)); + } + CoordMap { + version: ds.version().version, + id_of, + } +} + +#[derive(Clone, Debug, Default)] +struct Io { + bytes_read: usize, + iops: usize, + requests: usize, + rows: usize, + counts: BTreeMap, +} + +/// One masked read: `coords` (by the map) into `_rowid`s, then a projection of +/// `coord` plus `cols`. Returns, per returned row, its stored coord and the +/// values of `cols` (None = null). +async fn masked_read( + ds: &Dataset, + map: &CoordMap, + coords: &[u32], + cols: &[usize], + style: MaterializationStyle, + check_version: bool, +) -> Result<(BTreeMap>>, Io), ReadError> { + if check_version && ds.version().version != map.version { + return Err(ReadError::StaleMapping { + map: map.version, + dataset: ds.version().version, + }); + } + let ids = coords.iter().filter_map(|c| map.id_of.get(c).copied()); + let mask = RowAddrMask::from_allowed(RowAddrTreeMap::from_iter(ids)); + read_with(ds, Some(mask), cols, style).await +} + +async fn read_with( + ds: &Dataset, + mask: Option, + cols: &[usize], + style: MaterializationStyle, +) -> Result<(BTreeMap>>, Io), ReadError> { + let mut names = vec!["coord".to_string()]; + names.extend(cols.iter().map(|&l| lane_name(l))); + let stats: Arc>> = Arc::new(Mutex::new(None)); + let sink = stats.clone(); + let mut s = ds.scan(); + s.project(&names).map_err(|e| ReadError::Lance(e.to_string()))?; + if let Some(m) = mask { + s.with_row_addr_prefilter(m); + } + s.materialization_style(style); + s.scan_stats_callback(Arc::new(move |c| { + *sink.lock().unwrap() = Some(Io { + bytes_read: c.bytes_read, + iops: c.iops, + requests: c.requests, + rows: 0, + counts: c.all_counts.iter().map(|(k, v)| (k.clone(), *v)).collect(), + }); + })); + let b = s + .try_into_batch() + .await + .map_err(|e| ReadError::Lance(e.to_string()))?; + let mut io = stats.lock().unwrap().clone().unwrap_or_default(); + io.rows = b.num_rows(); + Ok((align(&b, cols), io)) +} + +/// Values keyed by the row's stored coordinate (never by position). +fn align(b: &RecordBatch, cols: &[usize]) -> BTreeMap>> { + let coord = b + .column_by_name("coord") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let lanes: Vec<&FixedSizeBinaryArray> = cols + .iter() + .map(|&l| { + b.column_by_name(&lane_name(l)) + .unwrap() + .as_any() + .downcast_ref::() + .unwrap() + }) + .collect(); + let mut m = BTreeMap::new(); + for j in 0..b.num_rows() { + let v = lanes + .iter() + .map(|a| (!a.is_null(j)).then(|| a.value(j).try_into().unwrap())) + .collect(); + m.insert(coord.value(j), v); + } + m +} + +// ------------------------------------------------------------- benchmark + +fn style_name(s: &MaterializationStyle) -> &'static str { + match s { + MaterializationStyle::Heuristic => "heuristic", + MaterializationStyle::AllLate => "all_late", + MaterializationStyle::AllEarly => "all_early", + MaterializationStyle::AllEarlyExcept(_) => "all_early_except", + } +} + +fn styles() -> [MaterializationStyle; 3] { + [ + MaterializationStyle::Heuristic, + MaterializationStyle::AllLate, + MaterializationStyle::AllEarly, + ] +} + +fn median(mut v: Vec) -> f64 { + v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v[v.len() / 2] +} + +#[tokio::main(flavor = "multi_thread", worker_threads = 4)] +async fn main() { + println!("lance: 13.0.0 (resolved; see Cargo.lock of this probe crate)"); + println!( + "tier: {}", + if cfg!(target_feature = "avx512f") { + "v4 (avx512f)" + } else { + "below v4: timings not reportable" + } + ); + println!("csv,strategy,pattern,density,k,style,rows_emitted,bytes_read,iops,requests,wall_us"); + let dir = tempfile::tempdir().unwrap(); + let mut printed_keys = false; + for p in [Pattern::Uniform, Pattern::Clustered] { + for &d in &[0.001, 0.01, 0.1, 0.5, 1.0] { + let uri = dir.path().join(format!("{}_{d}", p.name())); + let uri = uri.to_str().unwrap(); + let coords: Vec = (0..N).collect(); + let ds = write(uri, vec![batch(&coords, p, d, 1)], WriteMode::Create, false, 1 << 20).await; + let map = build_map(&ds).await; + for &k in &[1usize, 2, 4, 8] { + let lanes: Vec = (0..k).collect(); + for style in styles() { + // unmasked baseline + let mut walls = Vec::new(); + let mut io = Io::default(); + for _ in 0..5 { + let t = Instant::now(); + let (_, i) = read_with(&ds, None, &lanes, style.clone()).await.unwrap(); + walls.push(t.elapsed().as_secs_f64() * 1e6); + io = i; + } + if !printed_keys { + println!("all_counts keys: {:?}", io.counts.keys().collect::>()); + printed_keys = true; + } + report("unmasked", p, d, k, &style, &io, median(walls)); + // combined: every requested lane present + let joint: Vec = coords + .iter() + .copied() + .filter(|&c| lanes.iter().all(|&l| present(p, d, l, c))) + .collect(); + let mut walls = Vec::new(); + for _ in 0..5 { + let t = Instant::now(); + let (_, i) = masked_read(&ds, &map, &joint, &lanes, style.clone(), true).await.unwrap(); + walls.push(t.elapsed().as_secs_f64() * 1e6); + io = i; + } + report("combined", p, d, k, &style, &io, median(walls)); + // independent: each lane with its own mask, aligned by coord + let mut walls = Vec::new(); + let mut sum = Io::default(); + for _ in 0..5 { + sum = Io::default(); + let t = Instant::now(); + for &l in &lanes { + let own: Vec = coords.iter().copied().filter(|&c| present(p, d, l, c)).collect(); + let (_, i) = masked_read(&ds, &map, &own, &[l], style.clone(), true).await.unwrap(); + sum.bytes_read += i.bytes_read; + sum.iops += i.iops; + sum.requests += i.requests; + sum.rows += i.rows; + } + walls.push(t.elapsed().as_secs_f64() * 1e6); + } + report("independent", p, d, k, &style, &sum, median(walls)); + } + } + } + } +} + +fn report(strategy: &str, p: Pattern, d: f64, k: usize, s: &MaterializationStyle, io: &Io, wall_us: f64) { + println!( + "csv,{strategy},{},{d},{k},{},{},{},{},{},{wall_us:.1}", + p.name(), + style_name(s), + io.rows, + io.bytes_read, + io.iops, + io.requests + ); +} + +// ------------------------------------------------------------- tests + +#[cfg(test)] +mod tests { + use super::*; + + const TN: u32 = 4_096; + + fn coords(r: std::ops::Range) -> Vec { + r.collect() + } + + /// Expected value of lane `l` at `c` (epoch `e`), as the reference. + fn want(p: Pattern, d: f64, l: usize, c: u32, e: u32) -> Option { + present(p, d, l, c).then(|| value(l, c, e)) + } + + fn sample(n: u32) -> Vec { + (0..64).map(|j| (mix(0x5A ^ j) % n as u64) as u32).collect() + } + + async fn check(ds: &Dataset, map: &CoordMap, cs: &[u32], epoch_of: impl Fn(u32) -> u32) { + let lanes = [0usize, 3]; + let (got, _) = masked_read(ds, map, cs, &lanes, MaterializationStyle::Heuristic, true) + .await + .unwrap(); + for (&c, vals) in &got { + assert!(cs.contains(&c), "coord {c} was not requested"); + for (j, &l) in lanes.iter().enumerate() { + assert_eq!(vals[j], want(Pattern::Uniform, 0.5, l, c, epoch_of(c)), "lane {l} at {c}"); + } + } + for &c in cs { + if map.id_of.contains_key(&c) { + assert!(got.contains_key(&c), "coord {c} missing from the read"); + } + } + } + + /// Oracle 8: combined and independent masked reads equal the reference. + #[tokio::test] + async fn masked_reads_equal_the_reference() { + let dir = tempfile::tempdir().unwrap(); + let uri = dir.path().join("t"); + let uri = uri.to_str().unwrap(); + let ds = write(uri, vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Create, false, 1 << 20).await; + let map = build_map(&ds).await; + let lanes = [1usize, 2]; + let joint: Vec = (0..TN).filter(|&c| lanes.iter().all(|&l| present(Pattern::Uniform, 0.5, l, c))).collect(); + assert!(joint.len() > 500 && joint.len() < 2000, "joint population {}", joint.len()); + let (got, io) = masked_read(&ds, &map, &joint, &lanes, MaterializationStyle::Heuristic, true).await.unwrap(); + assert_eq!(io.rows, joint.len()); + for &c in &joint { + for (j, &l) in lanes.iter().enumerate() { + assert_eq!(got[&c][j], want(Pattern::Uniform, 0.5, l, c, 1)); + assert!(got[&c][j].is_some()); + } + } + for &l in &lanes { + let own: Vec = (0..TN).filter(|&c| present(Pattern::Uniform, 0.5, l, c)).collect(); + let (got, _) = masked_read(&ds, &map, &own, &[l], MaterializationStyle::AllLate, true).await.unwrap(); + assert_eq!(got.len(), own.len()); + for &c in &own { + assert_eq!(got[&c][0], want(Pattern::Uniform, 0.5, l, c, 1)); + } + } + } + + /// Oracle 9: attribution is by stored coordinate; reversing the batch + /// leaves it unchanged, while positional attribution would not. + #[tokio::test] + async fn read_order_cannot_change_identity() { + let cs = coords(0..256); + let b = batch(&cs, Pattern::Uniform, 0.5, 1); + // the same rows in reverse order + let rev = batch(&cs.iter().rev().copied().collect::>(), Pattern::Uniform, 0.5, 1); + assert_eq!(align(&b, &[0, 1]), align(&rev, &[0, 1])); + // positional attribution of the reversed batch disagrees + let lane0 = rev.column_by_name("lane_0").unwrap().as_any().downcast_ref::().unwrap(); + let positional_wrong = (0..256).filter(|&j| { + let by_pos: Option = (!lane0.is_null(j)).then(|| lane0.value(j).try_into().unwrap()); + by_pos != want(Pattern::Uniform, 0.5, 0, j as u32, 1) + }).count(); + assert!(positional_wrong > 100, "the fixture must make position and coord disagree"); + } + + /// Oracle 10 and § 8: every identity scenario returns the requested + /// coordinates or refuses; none returns a wrong coordinate. + #[tokio::test] + async fn identity_survives_or_refuses_across_rewrites() { + for stable in [false, true] { + let dir = tempfile::tempdir().unwrap(); + let uri = dir.path().join("id"); + let uri = uri.to_str().unwrap(); + // initial append (two fragments of 1,024 rows) + let mut ds = write(uri, vec![batch(&coords(0..2048), Pattern::Uniform, 0.5, 1)], WriteMode::Create, stable, 1024).await; + let m1 = build_map(&ds).await; + check(&ds, &m1, &sample(2048), |_| 1).await; + // second append + ds = write(uri, vec![batch(&coords(2048..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Append, stable, 1024).await; + assert!(matches!( + masked_read(&ds, &m1, &[1], &[0], MaterializationStyle::Heuristic, true).await, + Err(ReadError::StaleMapping { .. }) + )); + let m2 = build_map(&ds).await; + check(&ds, &m2, &sample(TN), |_| 1).await; + // delete + ds.delete("coord % 7 = 0").await.unwrap(); + let m3 = build_map(&ds).await; + assert!(!m3.id_of.contains_key(&7)); + let (got, _) = masked_read(&ds, &m3, &[7, 8], &[0], MaterializationStyle::Heuristic, true).await.unwrap(); + assert!(!got.contains_key(&7) && got.contains_key(&8)); + check(&ds, &m3, &sample(TN), |_| 1).await; + // update: epoch 2 for coord < 100, lane values rewritten in place + let upd = lance::dataset::UpdateBuilder::new(Arc::new(ds.clone())) + .update_where("coord < 100").unwrap() + .set("epoch", "2").unwrap() + .build().unwrap() + .execute().await.unwrap(); + ds = (*upd.new_dataset).clone(); + let m4 = build_map(&ds).await; + let moved = (0..100u32).filter(|c| m3.id_of.get(c).is_some() && m3.id_of.get(c) != m4.id_of.get(c)).count(); + println!("stable={stable}: update moved {moved} of the updated rows' _rowid"); + check(&ds, &m4, &sample(TN), |_| 1).await; // lane values unchanged by the epoch update + // reopen: same version, the map stays valid + let reopened = Dataset::open(uri).await.unwrap(); + assert_eq!(reopened.version().version, m4.version); + check(&reopened, &m4, &sample(TN), |_| 1).await; + // compaction + lance::dataset::optimize::compact_files(&mut ds, Default::default(), None).await.unwrap(); + assert!(matches!( + masked_read(&ds, &m4, &[8], &[0], MaterializationStyle::Heuristic, true).await, + Err(ReadError::StaleMapping { .. }) + )); + let m5 = build_map(&ds).await; + let changed = m4.id_of.iter().filter(|(c, id)| m5.id_of.get(c) != Some(id)).count(); + println!("stable={stable}: compaction changed {changed} of {} _rowid", m4.id_of.len()); + if stable { + assert_eq!(changed, 0, "stable row ids must survive compaction"); + } + check(&ds, &m5, &sample(TN), |_| 1).await; + // version transition: the old version with its own map + let old = ds.checkout_version(m2.version).await.unwrap(); + check(&old, &m2, &sample(TN), |_| 1).await; + // same-row-count rewrite: overwrite with the coordinates reversed + let rev: Vec = (0..TN).rev().collect(); + ds = write(uri, vec![batch(&rev, Pattern::Uniform, 0.5, 1)], WriteMode::Overwrite, stable, 1024).await; + assert!(matches!( + masked_read(&ds, &m5, &[8], &[0], MaterializationStyle::Heuristic, true).await, + Err(ReadError::StaleMapping { .. }) + )); + let m6 = build_map(&ds).await; + check(&ds, &m6, &sample(TN), |_| 1).await; + } + } + + /// The version check is load-bearing: after a reordering rewrite the old + /// map, used without the check, attributes rows to the wrong coordinates. + #[tokio::test] + async fn an_unchecked_stale_map_returns_wrong_coordinates() { + let dir = tempfile::tempdir().unwrap(); + let uri = dir.path().join("stale"); + let uri = uri.to_str().unwrap(); + let ds = write(uri, vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Create, false, 1 << 20).await; + let m1 = build_map(&ds).await; + let rev: Vec = (0..TN).rev().collect(); + let ds = write(uri, vec![batch(&rev, Pattern::Uniform, 0.5, 1)], WriteMode::Overwrite, false, 1 << 20).await; + let asked = [5u32, 6, 7]; + let (got, _) = masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, false).await.unwrap(); + let wrong = got.keys().filter(|c| !asked.contains(c)).count(); + assert!(wrong > 0, "the hazard must be real for the version check to matter"); + assert!(matches!( + masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, true).await, + Err(ReadError::StaleMapping { .. }) + )); + } + + /// A missing lane column or a missing lane dataset fails explicitly. + #[tokio::test] + async fn a_missing_lane_fails_explicitly() { + let dir = tempfile::tempdir().unwrap(); + let uri = dir.path().join("m"); + let uri = uri.to_str().unwrap(); + let ds = write(uri, vec![batch(&coords(0..64), Pattern::Uniform, 0.5, 1)], WriteMode::Create, false, 1 << 20).await; + let map = build_map(&ds).await; + assert!(matches!( + masked_read(&ds, &map, &[1], &[LANES + 3], MaterializationStyle::Heuristic, true).await, + Err(ReadError::Lance(_)) + )); + assert!(Dataset::open(dir.path().join("absent").to_str().unwrap()).await.is_err()); + } +} From e0351cbdb70e8a26cf27d19576203c2e0806c8c9 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 23:17:43 +0000 Subject: [PATCH 5/9] D-HOLO H14c: stale-map hazard is silent omission; measure it across overwrite, delete+compact, update, stable on/off Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- crates/holo-lance-masked-io-probe/src/main.rs | 57 +++++++++++++------ 1 file changed, 41 insertions(+), 16 deletions(-) diff --git a/crates/holo-lance-masked-io-probe/src/main.rs b/crates/holo-lance-masked-io-probe/src/main.rs index 212de8c66..c6018ed2b 100644 --- a/crates/holo-lance-masked-io-probe/src/main.rs +++ b/crates/holo-lance-masked-io-probe/src/main.rs @@ -546,22 +546,47 @@ mod tests { /// The version check is load-bearing: after a reordering rewrite the old /// map, used without the check, attributes rows to the wrong coordinates. #[tokio::test] - async fn an_unchecked_stale_map_returns_wrong_coordinates() { - let dir = tempfile::tempdir().unwrap(); - let uri = dir.path().join("stale"); - let uri = uri.to_str().unwrap(); - let ds = write(uri, vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Create, false, 1 << 20).await; - let m1 = build_map(&ds).await; - let rev: Vec = (0..TN).rev().collect(); - let ds = write(uri, vec![batch(&rev, Pattern::Uniform, 0.5, 1)], WriteMode::Overwrite, false, 1 << 20).await; - let asked = [5u32, 6, 7]; - let (got, _) = masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, false).await.unwrap(); - let wrong = got.keys().filter(|c| !asked.contains(c)).count(); - assert!(wrong > 0, "the hazard must be real for the version check to matter"); - assert!(matches!( - masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, true).await, - Err(ReadError::StaleMapping { .. }) - )); + async fn an_unchecked_stale_map_returns_a_wrong_answer() { + let asked: Vec = (0..TN).step_by(17).collect(); + let mut outcomes = Vec::new(); + for (name, stable) in [("overwrite-reversed", false), ("delete+compact", false), ("update", false), ("overwrite-reversed", true), ("delete+compact", true), ("update", true)] { + let dir = tempfile::tempdir().unwrap(); + let uri = dir.path().join("stale"); + let uri = uri.to_str().unwrap(); + let mut ds = write(uri, vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Create, stable, 1024).await; + let m1 = build_map(&ds).await; + match name { + "overwrite-reversed" => { + let rev: Vec = (0..TN).rev().collect(); + ds = write(uri, vec![batch(&rev, Pattern::Uniform, 0.5, 1)], WriteMode::Overwrite, stable, 1024).await; + } + "delete+compact" => { + ds.delete("coord % 3 = 0").await.unwrap(); + lance::dataset::optimize::compact_files(&mut ds, Default::default(), None).await.unwrap(); + } + _ => { + let upd = lance::dataset::UpdateBuilder::new(Arc::new(ds.clone())) + .update_where("coord < 2000").unwrap() + .set("epoch", "2").unwrap() + .build().unwrap() + .execute().await.unwrap(); + ds = (*upd.new_dataset).clone(); + } + } + let fresh = build_map(&ds).await; + let want: Vec = asked.iter().copied().filter(|c| fresh.id_of.contains_key(c)).collect(); + let (got, _) = masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, false).await.unwrap(); + let wrong = got.keys().filter(|c| !asked.contains(c)).count(); + let missing = want.iter().filter(|c| !got.contains_key(c)).count(); + let extra_deleted = got.keys().filter(|c| asked.contains(c) && !fresh.id_of.contains_key(c)).count(); + println!("stale map, {name}, stable={stable}: asked {}, live {}, returned {}, wrong coord {wrong}, silently missing {missing}, deleted returned {extra_deleted}", asked.len(), want.len(), got.len()); + outcomes.push(wrong + missing + extra_deleted); + assert!(matches!( + masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, true).await, + Err(ReadError::StaleMapping { .. }) + )); + } + assert!(outcomes.iter().any(|&n| n > 0), "the hazard must be real for the version check to matter"); } /// A missing lane column or a missing lane dataset fails explicitly. From afbf2433612408575c07f4bff8ba99c413dbbd62 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 23:34:03 +0000 Subject: [PATCH 6/9] D-HOLO H14c: memory cells in child processes (allocator reuse zeroed the deltas); Lance rows_scanned/ranges_scanned columns; fmt, clippy Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- crates/holo-lance-masked-io-probe/src/main.rs | 308 ++++++++-- .../examples/holo_thought_first_probe.rs | 565 +++++++++++++++--- 2 files changed, 744 insertions(+), 129 deletions(-) diff --git a/crates/holo-lance-masked-io-probe/src/main.rs b/crates/holo-lance-masked-io-probe/src/main.rs index c6018ed2b..6fce2b906 100644 --- a/crates/holo-lance-masked-io-probe/src/main.rs +++ b/crates/holo-lance-masked-io-probe/src/main.rs @@ -95,7 +95,11 @@ fn schema() -> Arc { Field::new("epoch", DataType::UInt32, false), ]; for l in 0..LANES { - f.push(Field::new(lane_name(l), DataType::FixedSizeBinary(LANE as i32), true)); + f.push(Field::new( + lane_name(l), + DataType::FixedSizeBinary(LANE as i32), + true, + )); } Arc::new(Schema::new(f)) } @@ -224,7 +228,8 @@ async fn read_with( let stats: Arc>> = Arc::new(Mutex::new(None)); let sink = stats.clone(); let mut s = ds.scan(); - s.project(&names).map_err(|e| ReadError::Lance(e.to_string()))?; + s.project(&names) + .map_err(|e| ReadError::Lance(e.to_string()))?; if let Some(m) = mask { s.with_row_addr_prefilter(m); } @@ -311,7 +316,7 @@ async fn main() { "below v4: timings not reportable" } ); - println!("csv,strategy,pattern,density,k,style,rows_emitted,bytes_read,iops,requests,wall_us"); + println!("csv,strategy,pattern,density,k,style,rows_emitted,bytes_read,iops,requests,rows_scanned,ranges_scanned,wall_us"); let dir = tempfile::tempdir().unwrap(); let mut printed_keys = false; for p in [Pattern::Uniform, Pattern::Clustered] { @@ -319,7 +324,14 @@ async fn main() { let uri = dir.path().join(format!("{}_{d}", p.name())); let uri = uri.to_str().unwrap(); let coords: Vec = (0..N).collect(); - let ds = write(uri, vec![batch(&coords, p, d, 1)], WriteMode::Create, false, 1 << 20).await; + let ds = write( + uri, + vec![batch(&coords, p, d, 1)], + WriteMode::Create, + false, + 1 << 20, + ) + .await; let map = build_map(&ds).await; for &k in &[1usize, 2, 4, 8] { let lanes: Vec = (0..k).collect(); @@ -334,7 +346,10 @@ async fn main() { io = i; } if !printed_keys { - println!("all_counts keys: {:?}", io.counts.keys().collect::>()); + println!( + "all_counts keys: {:?}", + io.counts.keys().collect::>() + ); printed_keys = true; } report("unmasked", p, d, k, &style, &io, median(walls)); @@ -347,7 +362,9 @@ async fn main() { let mut walls = Vec::new(); for _ in 0..5 { let t = Instant::now(); - let (_, i) = masked_read(&ds, &map, &joint, &lanes, style.clone(), true).await.unwrap(); + let (_, i) = masked_read(&ds, &map, &joint, &lanes, style.clone(), true) + .await + .unwrap(); walls.push(t.elapsed().as_secs_f64() * 1e6); io = i; } @@ -359,12 +376,21 @@ async fn main() { sum = Io::default(); let t = Instant::now(); for &l in &lanes { - let own: Vec = coords.iter().copied().filter(|&c| present(p, d, l, c)).collect(); - let (_, i) = masked_read(&ds, &map, &own, &[l], style.clone(), true).await.unwrap(); + let own: Vec = coords + .iter() + .copied() + .filter(|&c| present(p, d, l, c)) + .collect(); + let (_, i) = masked_read(&ds, &map, &own, &[l], style.clone(), true) + .await + .unwrap(); sum.bytes_read += i.bytes_read; sum.iops += i.iops; sum.requests += i.requests; sum.rows += i.rows; + for (key, v) in i.counts { + *sum.counts.entry(key).or_default() += v; + } } walls.push(t.elapsed().as_secs_f64() * 1e6); } @@ -375,15 +401,25 @@ async fn main() { } } -fn report(strategy: &str, p: Pattern, d: f64, k: usize, s: &MaterializationStyle, io: &Io, wall_us: f64) { +fn report( + strategy: &str, + p: Pattern, + d: f64, + k: usize, + s: &MaterializationStyle, + io: &Io, + wall_us: f64, +) { println!( - "csv,{strategy},{},{d},{k},{},{},{},{},{},{wall_us:.1}", + "csv,{strategy},{},{d},{k},{},{},{},{},{},{},{},{wall_us:.1}", p.name(), style_name(s), io.rows, io.bytes_read, io.iops, - io.requests + io.requests, + io.counts.get("rows_scanned").copied().unwrap_or(0), + io.counts.get("ranges_scanned").copied().unwrap_or(0) ); } @@ -416,7 +452,11 @@ mod tests { for (&c, vals) in &got { assert!(cs.contains(&c), "coord {c} was not requested"); for (j, &l) in lanes.iter().enumerate() { - assert_eq!(vals[j], want(Pattern::Uniform, 0.5, l, c, epoch_of(c)), "lane {l} at {c}"); + assert_eq!( + vals[j], + want(Pattern::Uniform, 0.5, l, c, epoch_of(c)), + "lane {l} at {c}" + ); } } for &c in cs { @@ -432,12 +472,34 @@ mod tests { let dir = tempfile::tempdir().unwrap(); let uri = dir.path().join("t"); let uri = uri.to_str().unwrap(); - let ds = write(uri, vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Create, false, 1 << 20).await; + let ds = write( + uri, + vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], + WriteMode::Create, + false, + 1 << 20, + ) + .await; let map = build_map(&ds).await; let lanes = [1usize, 2]; - let joint: Vec = (0..TN).filter(|&c| lanes.iter().all(|&l| present(Pattern::Uniform, 0.5, l, c))).collect(); - assert!(joint.len() > 500 && joint.len() < 2000, "joint population {}", joint.len()); - let (got, io) = masked_read(&ds, &map, &joint, &lanes, MaterializationStyle::Heuristic, true).await.unwrap(); + let joint: Vec = (0..TN) + .filter(|&c| lanes.iter().all(|&l| present(Pattern::Uniform, 0.5, l, c))) + .collect(); + assert!( + joint.len() > 500 && joint.len() < 2000, + "joint population {}", + joint.len() + ); + let (got, io) = masked_read( + &ds, + &map, + &joint, + &lanes, + MaterializationStyle::Heuristic, + true, + ) + .await + .unwrap(); assert_eq!(io.rows, joint.len()); for &c in &joint { for (j, &l) in lanes.iter().enumerate() { @@ -446,8 +508,12 @@ mod tests { } } for &l in &lanes { - let own: Vec = (0..TN).filter(|&c| present(Pattern::Uniform, 0.5, l, c)).collect(); - let (got, _) = masked_read(&ds, &map, &own, &[l], MaterializationStyle::AllLate, true).await.unwrap(); + let own: Vec = (0..TN) + .filter(|&c| present(Pattern::Uniform, 0.5, l, c)) + .collect(); + let (got, _) = masked_read(&ds, &map, &own, &[l], MaterializationStyle::AllLate, true) + .await + .unwrap(); assert_eq!(got.len(), own.len()); for &c in &own { assert_eq!(got[&c][0], want(Pattern::Uniform, 0.5, l, c, 1)); @@ -462,15 +528,31 @@ mod tests { let cs = coords(0..256); let b = batch(&cs, Pattern::Uniform, 0.5, 1); // the same rows in reverse order - let rev = batch(&cs.iter().rev().copied().collect::>(), Pattern::Uniform, 0.5, 1); + let rev = batch( + &cs.iter().rev().copied().collect::>(), + Pattern::Uniform, + 0.5, + 1, + ); assert_eq!(align(&b, &[0, 1]), align(&rev, &[0, 1])); // positional attribution of the reversed batch disagrees - let lane0 = rev.column_by_name("lane_0").unwrap().as_any().downcast_ref::().unwrap(); - let positional_wrong = (0..256).filter(|&j| { - let by_pos: Option = (!lane0.is_null(j)).then(|| lane0.value(j).try_into().unwrap()); - by_pos != want(Pattern::Uniform, 0.5, 0, j as u32, 1) - }).count(); - assert!(positional_wrong > 100, "the fixture must make position and coord disagree"); + let lane0 = rev + .column_by_name("lane_0") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let positional_wrong = (0..256) + .filter(|&j| { + let by_pos: Option = + (!lane0.is_null(j)).then(|| lane0.value(j).try_into().unwrap()); + by_pos != want(Pattern::Uniform, 0.5, 0, j as u32, 1) + }) + .count(); + assert!( + positional_wrong > 100, + "the fixture must make position and coord disagree" + ); } /// Oracle 10 and § 8: every identity scenario returns the requested @@ -482,11 +564,25 @@ mod tests { let uri = dir.path().join("id"); let uri = uri.to_str().unwrap(); // initial append (two fragments of 1,024 rows) - let mut ds = write(uri, vec![batch(&coords(0..2048), Pattern::Uniform, 0.5, 1)], WriteMode::Create, stable, 1024).await; + let mut ds = write( + uri, + vec![batch(&coords(0..2048), Pattern::Uniform, 0.5, 1)], + WriteMode::Create, + stable, + 1024, + ) + .await; let m1 = build_map(&ds).await; check(&ds, &m1, &sample(2048), |_| 1).await; // second append - ds = write(uri, vec![batch(&coords(2048..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Append, stable, 1024).await; + ds = write( + uri, + vec![batch(&coords(2048..TN), Pattern::Uniform, 0.5, 1)], + WriteMode::Append, + stable, + 1024, + ) + .await; assert!(matches!( masked_read(&ds, &m1, &[1], &[0], MaterializationStyle::Heuristic, true).await, Err(ReadError::StaleMapping { .. }) @@ -497,33 +593,58 @@ mod tests { ds.delete("coord % 7 = 0").await.unwrap(); let m3 = build_map(&ds).await; assert!(!m3.id_of.contains_key(&7)); - let (got, _) = masked_read(&ds, &m3, &[7, 8], &[0], MaterializationStyle::Heuristic, true).await.unwrap(); + let (got, _) = masked_read( + &ds, + &m3, + &[7, 8], + &[0], + MaterializationStyle::Heuristic, + true, + ) + .await + .unwrap(); assert!(!got.contains_key(&7) && got.contains_key(&8)); check(&ds, &m3, &sample(TN), |_| 1).await; // update: epoch 2 for coord < 100, lane values rewritten in place let upd = lance::dataset::UpdateBuilder::new(Arc::new(ds.clone())) - .update_where("coord < 100").unwrap() - .set("epoch", "2").unwrap() - .build().unwrap() - .execute().await.unwrap(); + .update_where("coord < 100") + .unwrap() + .set("epoch", "2") + .unwrap() + .build() + .unwrap() + .execute() + .await + .unwrap(); ds = (*upd.new_dataset).clone(); let m4 = build_map(&ds).await; - let moved = (0..100u32).filter(|c| m3.id_of.get(c).is_some() && m3.id_of.get(c) != m4.id_of.get(c)).count(); + let moved = (0..100u32) + .filter(|c| m3.id_of.contains_key(c) && m3.id_of.get(c) != m4.id_of.get(c)) + .count(); println!("stable={stable}: update moved {moved} of the updated rows' _rowid"); check(&ds, &m4, &sample(TN), |_| 1).await; // lane values unchanged by the epoch update - // reopen: same version, the map stays valid + // reopen: same version, the map stays valid let reopened = Dataset::open(uri).await.unwrap(); assert_eq!(reopened.version().version, m4.version); check(&reopened, &m4, &sample(TN), |_| 1).await; // compaction - lance::dataset::optimize::compact_files(&mut ds, Default::default(), None).await.unwrap(); + lance::dataset::optimize::compact_files(&mut ds, Default::default(), None) + .await + .unwrap(); assert!(matches!( masked_read(&ds, &m4, &[8], &[0], MaterializationStyle::Heuristic, true).await, Err(ReadError::StaleMapping { .. }) )); let m5 = build_map(&ds).await; - let changed = m4.id_of.iter().filter(|(c, id)| m5.id_of.get(c) != Some(id)).count(); - println!("stable={stable}: compaction changed {changed} of {} _rowid", m4.id_of.len()); + let changed = m4 + .id_of + .iter() + .filter(|(c, id)| m5.id_of.get(c) != Some(id)) + .count(); + println!( + "stable={stable}: compaction changed {changed} of {} _rowid", + m4.id_of.len() + ); if stable { assert_eq!(changed, 0, "stable row ids must survive compaction"); } @@ -533,7 +654,14 @@ mod tests { check(&old, &m2, &sample(TN), |_| 1).await; // same-row-count rewrite: overwrite with the coordinates reversed let rev: Vec = (0..TN).rev().collect(); - ds = write(uri, vec![batch(&rev, Pattern::Uniform, 0.5, 1)], WriteMode::Overwrite, stable, 1024).await; + ds = write( + uri, + vec![batch(&rev, Pattern::Uniform, 0.5, 1)], + WriteMode::Overwrite, + stable, + 1024, + ) + .await; assert!(matches!( masked_read(&ds, &m5, &[8], &[0], MaterializationStyle::Heuristic, true).await, Err(ReadError::StaleMapping { .. }) @@ -549,44 +677,99 @@ mod tests { async fn an_unchecked_stale_map_returns_a_wrong_answer() { let asked: Vec = (0..TN).step_by(17).collect(); let mut outcomes = Vec::new(); - for (name, stable) in [("overwrite-reversed", false), ("delete+compact", false), ("update", false), ("overwrite-reversed", true), ("delete+compact", true), ("update", true)] { + for (name, stable) in [ + ("overwrite-reversed", false), + ("delete+compact", false), + ("update", false), + ("overwrite-reversed", true), + ("delete+compact", true), + ("update", true), + ] { let dir = tempfile::tempdir().unwrap(); let uri = dir.path().join("stale"); let uri = uri.to_str().unwrap(); - let mut ds = write(uri, vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], WriteMode::Create, stable, 1024).await; + let mut ds = write( + uri, + vec![batch(&coords(0..TN), Pattern::Uniform, 0.5, 1)], + WriteMode::Create, + stable, + 1024, + ) + .await; let m1 = build_map(&ds).await; match name { "overwrite-reversed" => { let rev: Vec = (0..TN).rev().collect(); - ds = write(uri, vec![batch(&rev, Pattern::Uniform, 0.5, 1)], WriteMode::Overwrite, stable, 1024).await; + ds = write( + uri, + vec![batch(&rev, Pattern::Uniform, 0.5, 1)], + WriteMode::Overwrite, + stable, + 1024, + ) + .await; } "delete+compact" => { ds.delete("coord % 3 = 0").await.unwrap(); - lance::dataset::optimize::compact_files(&mut ds, Default::default(), None).await.unwrap(); + lance::dataset::optimize::compact_files(&mut ds, Default::default(), None) + .await + .unwrap(); } _ => { let upd = lance::dataset::UpdateBuilder::new(Arc::new(ds.clone())) - .update_where("coord < 2000").unwrap() - .set("epoch", "2").unwrap() - .build().unwrap() - .execute().await.unwrap(); + .update_where("coord < 2000") + .unwrap() + .set("epoch", "2") + .unwrap() + .build() + .unwrap() + .execute() + .await + .unwrap(); ds = (*upd.new_dataset).clone(); } } let fresh = build_map(&ds).await; - let want: Vec = asked.iter().copied().filter(|c| fresh.id_of.contains_key(c)).collect(); - let (got, _) = masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, false).await.unwrap(); + let want: Vec = asked + .iter() + .copied() + .filter(|c| fresh.id_of.contains_key(c)) + .collect(); + let (got, _) = masked_read( + &ds, + &m1, + &asked, + &[0], + MaterializationStyle::Heuristic, + false, + ) + .await + .unwrap(); let wrong = got.keys().filter(|c| !asked.contains(c)).count(); let missing = want.iter().filter(|c| !got.contains_key(c)).count(); - let extra_deleted = got.keys().filter(|c| asked.contains(c) && !fresh.id_of.contains_key(c)).count(); + let extra_deleted = got + .keys() + .filter(|c| asked.contains(c) && !fresh.id_of.contains_key(c)) + .count(); println!("stale map, {name}, stable={stable}: asked {}, live {}, returned {}, wrong coord {wrong}, silently missing {missing}, deleted returned {extra_deleted}", asked.len(), want.len(), got.len()); outcomes.push(wrong + missing + extra_deleted); assert!(matches!( - masked_read(&ds, &m1, &asked, &[0], MaterializationStyle::Heuristic, true).await, + masked_read( + &ds, + &m1, + &asked, + &[0], + MaterializationStyle::Heuristic, + true + ) + .await, Err(ReadError::StaleMapping { .. }) )); } - assert!(outcomes.iter().any(|&n| n > 0), "the hazard must be real for the version check to matter"); + assert!( + outcomes.iter().any(|&n| n > 0), + "the hazard must be real for the version check to matter" + ); } /// A missing lane column or a missing lane dataset fails explicitly. @@ -595,12 +778,29 @@ mod tests { let dir = tempfile::tempdir().unwrap(); let uri = dir.path().join("m"); let uri = uri.to_str().unwrap(); - let ds = write(uri, vec![batch(&coords(0..64), Pattern::Uniform, 0.5, 1)], WriteMode::Create, false, 1 << 20).await; + let ds = write( + uri, + vec![batch(&coords(0..64), Pattern::Uniform, 0.5, 1)], + WriteMode::Create, + false, + 1 << 20, + ) + .await; let map = build_map(&ds).await; assert!(matches!( - masked_read(&ds, &map, &[1], &[LANES + 3], MaterializationStyle::Heuristic, true).await, + masked_read( + &ds, + &map, + &[1], + &[LANES + 3], + MaterializationStyle::Heuristic, + true + ) + .await, Err(ReadError::Lance(_)) )); - assert!(Dataset::open(dir.path().join("absent").to_str().unwrap()).await.is_err()); + assert!(Dataset::open(dir.path().join("absent").to_str().unwrap()) + .await + .is_err()); } } diff --git a/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs b/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs index 09221874a..dd089f5ee 100644 --- a/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs +++ b/crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs @@ -73,7 +73,7 @@ fn overlay_value(t: usize, l: usize, i: usize) -> Val { /// The immutable base: one 512-byte row per address (the given). fn base_rows() -> Vec { let mut b = vec![0u8; N * ROW]; - for (i, row) in b.chunks_exact_mut(ROW).enumerate() { + for (i, row) in b.as_chunks_mut::().0.iter_mut().enumerate() { for l in 0..LANES { let v = mix(0xBA5E ^ ((l as u64) << 32) ^ i as u64).to_le_bytes(); row[l * LANE..l * LANE + 8].copy_from_slice(&v); @@ -479,7 +479,14 @@ impl ThoughtB { /// Lane `l` of row `i`: index lookup, mask test, popcount rank. #[inline] - fn read(&self, sel_lanes: &[usize], fallback: Fallback, base: &[u8], i: usize, out: &mut [Got]) { + fn read( + &self, + sel_lanes: &[usize], + fallback: Fallback, + base: &[u8], + i: usize, + out: &mut [Got], + ) { let r = self.rec_of[i]; for (o, &l) in out.iter_mut().zip(sel_lanes) { *o = if r != NONE && self.masks[r as usize] >> l & 1 == 1 { @@ -532,7 +539,14 @@ impl ThoughtS { } #[inline] - fn read(&self, sel_lanes: &[usize], fallback: Fallback, base: &[u8], i: usize, out: &mut [Got]) { + fn read( + &self, + sel_lanes: &[usize], + fallback: Fallback, + base: &[u8], + i: usize, + out: &mut [Got], + ) { for (o, &l) in out.iter_mut().zip(sel_lanes) { let hit = self.lanes[l].as_ref().and_then(|s| { count!(TRANSLATIONS); @@ -593,7 +607,12 @@ fn xor_count_program() -> Program { /// `popcount(OR of n planes)`: the session-wide population. fn or_count_program(n: u16) -> Program { if n == 1 { - return Program::new(vec![], Terminal::Count { mask: MOp::Plane(0) }); + return Program::new( + vec![], + Terminal::Count { + mask: MOp::Plane(0), + }, + ); } let mut ops = vec![MaskOp::Or { a: MOp::Plane(0), @@ -641,7 +660,12 @@ fn scalar_xor(a: &[u64], b: &[u64]) -> usize { /// Parsed from the program's `Debug` form (`Plane(n)`, `lane: n`) so it /// covers every op and terminal variant without restating them; a lane field /// that is not a literal is not counted. -fn lane_footprint(p: &Program) -> (std::collections::BTreeSet, std::collections::BTreeSet) { +fn lane_footprint( + p: &Program, +) -> ( + std::collections::BTreeSet, + std::collections::BTreeSet, +) { let text = format!("{p:?}"); let grab = |key: &str, end: char| { text.match_indices(key) @@ -728,12 +752,23 @@ fn addrs_hot() -> Vec { } fn addrs_cold() -> Vec { - (0..READS).map(|j| (mix(0xC01D ^ j as u64) as usize) % N).collect() + (0..READS) + .map(|j| (mix(0xC01D ^ j as u64) as usize) % N) + .collect() } fn main() { let args: Vec = std::env::args().collect(); let only = args.get(1).map(String::as_str).unwrap_or("all"); + if only == "memcell" { + memory_cell( + &args[2], + args[3].parse().unwrap(), + args[4].parse().unwrap(), + &args[5], + ); + return; + } println!("tier: {}", tier()); println!( "host: MemTotal {} kB, batches 7 (median), reads per batch {READS}", @@ -826,7 +861,18 @@ fn main_grid(base: &[u8], ev: &mut [u64]) { } t.elapsed().as_nanos() as f64 / 1000.0 }; - row("A", "C", Pattern::Uniform, d, 1, u, k, "-", "resolve_ns", res_ns); + row( + "A", + "C", + Pattern::Uniform, + d, + 1, + u, + k, + "-", + "resolve_ns", + res_ns, + ); let r = resolve(&sel, &c, base); let mut out = vec![Got::Absent; k]; for (cache, addrs) in [("hot", &hot), ("cold", &cold)] { @@ -873,9 +919,42 @@ fn main_grid(base: &[u8], ev: &mut [u64]) { } }, ); - row("A", "C", Pattern::Uniform, d, 1, u, k, cache, "read_ns", ns_c); - row("A", "B", Pattern::Uniform, d, 1, u, k, cache, "read_ns", ns_b); - row("A", "S", Pattern::Uniform, d, 1, u, k, cache, "read_ns", ns_s); + row( + "A", + "C", + Pattern::Uniform, + d, + 1, + u, + k, + cache, + "read_ns", + ns_c, + ); + row( + "A", + "B", + Pattern::Uniform, + d, + 1, + u, + k, + cache, + "read_ns", + ns_b, + ); + row( + "A", + "S", + Pattern::Uniform, + d, + 1, + u, + k, + cache, + "read_ns", + ns_s, + ); } } if u >= 2 { @@ -888,14 +967,44 @@ fn main_grid(base: &[u8], ev: &mut [u64]) { let xor = xor_count_program(); let planes3: [&[u64]; 3] = [pa, pb, &ap]; let planes2: [&[u64]; 2] = [pa, pb]; - let ns_and = time_batches(WORDS, || {}, || { - black_box(run_count(&and3, black_box(&planes3))); - }); - let ns_xor = time_batches(WORDS, || {}, || { - black_box(run_count(&xor, black_box(&planes2))); - }); - row("B", "C", Pattern::Uniform, d, 1, u, 2, "hot", "shared_ns_per_word", ns_and); - row("B", "C", Pattern::Uniform, d, 1, u, 2, "hot", "hamming_ns_per_word", ns_xor); + let ns_and = time_batches( + WORDS, + || {}, + || { + black_box(run_count(&and3, black_box(&planes3))); + }, + ); + let ns_xor = time_batches( + WORDS, + || {}, + || { + black_box(run_count(&xor, black_box(&planes2))); + }, + ); + row( + "B", + "C", + Pattern::Uniform, + d, + 1, + u, + 2, + "hot", + "shared_ns_per_word", + ns_and, + ); + row( + "B", + "C", + Pattern::Uniform, + d, + 1, + u, + 2, + "hot", + "hamming_ns_per_word", + ns_xor, + ); row( "B", "C", @@ -912,11 +1021,15 @@ fn main_grid(base: &[u8], ev: &mut [u64]) { if u == 31 { // explicit terminal: rows built for 1,024 addresses let addrs: Vec = (0..1024).map(|j| (mix(0x7E ^ j) as usize) % N).collect(); - let ns = time_batches(1024, || {}, || { - for &i in &addrs { - black_box(materialize_row(&c[0], base, black_box(i))); - } - }); + let ns = time_batches( + 1024, + || {}, + || { + for &i in &addrs { + black_box(materialize_row(&c[0], base, black_box(i))); + } + }, + ); row("C", "C", Pattern::Uniform, d, 1, u, 31, "hot", "row_ns", ns); } } @@ -967,7 +1080,18 @@ fn thought_axis(base: &[u8], ev: &mut [u64]) { } }, ); - row("A", "C", Pattern::Uniform, d, tn, 31, 2, cache, "read_ns", ns); + row( + "A", + "C", + Pattern::Uniform, + d, + tn, + 31, + 2, + cache, + "read_ns", + ns, + ); } let l0 = lanes[0]; let planes: Vec<&[u64]> = cs @@ -975,10 +1099,25 @@ fn thought_axis(base: &[u8], ev: &mut [u64]) { .map(|c| c.tables[l0].as_ref().unwrap().present.as_slice()) .collect(); let prog = or_count_program(tn as u16); - let ns = time_batches(WORDS, || {}, || { - black_box(run_count(&prog, black_box(&planes))); - }); - row("B", "C", Pattern::Uniform, d, tn, 31, 1, "hot", "session_or_ns_per_word", ns); + let ns = time_batches( + WORDS, + || {}, + || { + black_box(run_count(&prog, black_box(&planes))); + }, + ); + row( + "B", + "C", + Pattern::Uniform, + d, + tn, + 31, + 1, + "hot", + "session_or_ns_per_word", + ns, + ); } } } @@ -1048,46 +1187,202 @@ fn spatial_axis(base: &[u8], ev: &mut [u64]) { let planes2: [&[u64]; 2] = [pa, pb]; let ap = vec![u64::MAX; WORDS]; let planes3: [&[u64]; 3] = [pa, pb, &ap]; - row("B", "C", p, d, 1, 31, 2, "-", "shared_count", run_count(&and_count_program(3), &planes3) as f64); - row("B", "C", p, d, 1, 31, 2, "-", "hamming", run_count(&xor_count_program(), &planes2) as f64); - row("B", "C", p, d, 1, 31, 2, "-", "pop_a", run_count(&or_count_program(1), &[pa.as_slice()]) as f64); + row( + "B", + "C", + p, + d, + 1, + 31, + 2, + "-", + "shared_count", + run_count(&and_count_program(3), &planes3) as f64, + ); + row( + "B", + "C", + p, + d, + 1, + 31, + 2, + "-", + "hamming", + run_count(&xor_count_program(), &planes2) as f64, + ); + row( + "B", + "C", + p, + d, + 1, + 31, + 2, + "-", + "pop_a", + run_count(&or_count_program(1), &[pa.as_slice()]) as f64, + ); } } } /// Resident cost of C-lazy, C-eager and S, per (T, density, pattern), U = 31. +/// Each (cell, arm) runs in its own child process: in one process the +/// allocator hands freed pages of the previous cell to the next one, and the +/// RSS and fault deltas read zero. fn memory_grid() { + let exe = std::env::current_exe().expect("own path"); for p in [Pattern::Uniform, Pattern::Clustered] { for &d in &[0.001, 0.01, 0.1, 1.0] { for &tn in &[1usize, 8, 64] { - let ws: Vec = (0..tn).map(|t| writes(p, d, t, 31)).collect(); - let dirty: usize = ws.iter().map(|w| w.lanes.iter().map(|(_, v)| v.len()).sum::()).sum(); - let tables = tn * 31; - row("M", "-", p, d, tn, 31, 0, "-", "logical_bytes", (tables * N * LANE) as f64); - row("M", "-", p, d, tn, 31, 0, "-", "payload_bytes", (dirty * LANE) as f64); - row("M", "-", p, d, tn, 31, 0, "-", "presence_bytes", (tables * WORDS * 8) as f64); - row("M", "-", p, d, tn, 31, 0, "-", "sparse_persist_bytes", (dirty * (4 + LANE)) as f64); - for (arm, commit) in [("C-lazy", Some(Commit::Lazy)), ("C-eager", Some(Commit::Eager)), ("S", None)] { - let m0 = mem(); - let t = Instant::now(); - let held: (Vec, Vec) = match commit { - Some(c) => (ws.iter().map(|w| ThoughtC::seal(w, c)).collect(), vec![]), - None => (vec![], ws.iter().map(ThoughtS::seal).collect()), - }; - let seal_ns = t.elapsed().as_nanos() as f64; - let m1 = mem(); - black_box(&held); - row("M", arm, p, d, tn, 31, 0, "-", "virtual_delta_bytes", ((m1.vm_kb as f64 - m0.vm_kb as f64) * 1024.0).max(0.0)); - row("M", arm, p, d, tn, 31, 0, "-", "rss_delta_bytes", ((m1.rss_kb as f64 - m0.rss_kb as f64) * 1024.0).max(0.0)); - row("M", arm, p, d, tn, 31, 0, "-", "minor_faults", (m1.flt - m0.flt) as f64); - row("M", arm, p, d, tn, 31, 0, "-", "seal_ns_per_dirty", if dirty > 0 { seal_ns / dirty as f64 } else { seal_ns }); - drop(held); + for arm in ["sizes", "C-lazy", "C-eager", "S"] { + let out = std::process::Command::new(&exe) + .args(["memcell", p.name(), &d.to_string(), &tn.to_string(), arm]) + .output() + .expect("child"); + print!("{}", String::from_utf8_lossy(&out.stdout)); } } } } } +fn memory_cell(p: &str, d: f64, tn: usize, arm: &str) { + let p = [Pattern::Uniform, Pattern::Clustered] + .into_iter() + .find(|x| x.name() == p) + .expect("pattern"); + let ws: Vec = (0..tn).map(|t| writes(p, d, t, 31)).collect(); + let dirty: usize = ws + .iter() + .map(|w| w.lanes.iter().map(|(_, v)| v.len()).sum::()) + .sum(); + let tables = tn * 31; + if arm == "sizes" { + row( + "M", + "-", + p, + d, + tn, + 31, + 0, + "-", + "logical_bytes", + (tables * N * LANE) as f64, + ); + row( + "M", + "-", + p, + d, + tn, + 31, + 0, + "-", + "payload_bytes", + (dirty * LANE) as f64, + ); + row( + "M", + "-", + p, + d, + tn, + 31, + 0, + "-", + "presence_bytes", + (tables * WORDS * 8) as f64, + ); + row( + "M", + "-", + p, + d, + tn, + 31, + 0, + "-", + "sparse_persist_bytes", + (dirty * (4 + LANE)) as f64, + ); + return; + } + let m0 = mem(); + let t = Instant::now(); + let held: (Vec, Vec) = match arm { + "C-lazy" => ( + ws.iter().map(|w| ThoughtC::seal(w, Commit::Lazy)).collect(), + vec![], + ), + "C-eager" => ( + ws.iter() + .map(|w| ThoughtC::seal(w, Commit::Eager)) + .collect(), + vec![], + ), + _ => (vec![], ws.iter().map(ThoughtS::seal).collect()), + }; + let seal_ns = t.elapsed().as_nanos() as f64; + let m1 = mem(); + black_box(&held); + let delta = |a: u64, b: u64| ((b as f64 - a as f64) * 1024.0).max(0.0); + row( + "M", + arm, + p, + d, + tn, + 31, + 0, + "-", + "virtual_delta_bytes", + delta(m0.vm_kb, m1.vm_kb), + ); + row( + "M", + arm, + p, + d, + tn, + 31, + 0, + "-", + "rss_delta_bytes", + delta(m0.rss_kb, m1.rss_kb), + ); + row( + "M", + arm, + p, + d, + tn, + 31, + 0, + "-", + "minor_faults", + (m1.flt - m0.flt) as f64, + ); + row( + "M", + arm, + p, + d, + tn, + 31, + 0, + "-", + "seal_ns_per_dirty", + if dirty > 0 { + seal_ns / dirty as f64 + } else { + seal_ns + }, + ); +} + // ------------------------------------------------------------- oracle tests #[cfg(test)] @@ -1126,7 +1421,15 @@ mod tests { let s = ThoughtS::seal(&w); let lanes = touched_lanes(31)[..4].to_vec(); for fb in [Fallback::Base, Fallback::Absent] { - let r = resolve(&Selection { thought: 0, lanes: lanes.clone(), fallback: fb }, &c, &base); + let r = resolve( + &Selection { + thought: 0, + lanes: lanes.clone(), + fallback: fb, + }, + &c, + &base, + ); let mut oc = vec![Got::Absent; 4]; let mut ob = vec![Got::Absent; 4]; let mut os = vec![Got::Absent; 4]; @@ -1154,7 +1457,15 @@ mod tests { let c = vec![ThoughtC::seal(&w, Commit::Lazy)]; assert_eq!(c[0].touched(), u, "the fixture must touch {u} tables"); let lanes = touched_lanes(u)[..2].to_vec(); - let r = resolve(&Selection { thought: 0, lanes, fallback: Fallback::Absent }, &c, &base); + let r = resolve( + &Selection { + thought: 0, + lanes, + fallback: Fallback::Absent, + }, + &c, + &base, + ); let mut out = vec![Got::Absent; 2]; reset(); for i in 0..1000 { @@ -1173,13 +1484,30 @@ mod tests { fn a_zero_overlay_is_not_absent() { let base = base_rows(); let l = touched_lanes(1)[0]; - let w = Writes { thought: 0, lanes: vec![(l, vec![5])] }; + let w = Writes { + thought: 0, + lanes: vec![(l, vec![5])], + }; let mut c = vec![ThoughtC::seal(&w, Commit::Lazy)]; c[0].tables[l].as_mut().unwrap().values[5] = [0; LANE]; - let r = resolve(&Selection { thought: 0, lanes: vec![l], fallback: Fallback::Absent }, &c, &base); + let r = resolve( + &Selection { + thought: 0, + lanes: vec![l], + fallback: Fallback::Absent, + }, + &c, + &base, + ); let mut out = [Got::Absent]; r.read(5, &mut out); - assert_eq!(out[0], Got::Overlay { thought: 0, value: [0; LANE] }); + assert_eq!( + out[0], + Got::Overlay { + thought: 0, + value: [0; LANE] + } + ); r.read(6, &mut out); assert_eq!(out[0], Got::Absent); } @@ -1191,14 +1519,32 @@ mod tests { let l = touched_lanes(4)[0]; let dirty = &w.lanes[0].1; let hit = dirty[0] as usize; - let miss = (0..N).find(|i| dirty.binary_search(&(*i as u32)).is_err()).unwrap(); + let miss = (0..N) + .find(|i| dirty.binary_search(&(*i as u32)).is_err()) + .unwrap(); let mut out = [Got::Absent]; - let rb = resolve(&Selection { thought: 0, lanes: vec![l], fallback: Fallback::Base }, &c, &base); + let rb = resolve( + &Selection { + thought: 0, + lanes: vec![l], + fallback: Fallback::Base, + }, + &c, + &base, + ); rb.read(hit, &mut out); assert!(matches!(out[0], Got::Overlay { .. })); rb.read(miss, &mut out); assert_eq!(out[0], Got::Base(base_lane(&base, miss, l))); - let ra = resolve(&Selection { thought: 0, lanes: vec![l], fallback: Fallback::Absent }, &c, &base); + let ra = resolve( + &Selection { + thought: 0, + lanes: vec![l], + fallback: Fallback::Absent, + }, + &c, + &base, + ); ra.read(miss, &mut out); assert_eq!(out[0], Got::Absent); } @@ -1206,7 +1552,12 @@ mod tests { /// Oracles 6 and 7: mask-risc populations equal a scalar bit loop. #[test] fn populations_equal_the_scalar_reference() { - for p in [Pattern::Uniform, Pattern::Clustered, Pattern::Disjoint, Pattern::Overlapping] { + for p in [ + Pattern::Uniform, + Pattern::Clustered, + Pattern::Disjoint, + Pattern::Overlapping, + ] { let w = writes(p, 0.1, 0, 4); let c = ThoughtC::seal(&w, Commit::Lazy); let l = touched_lanes(4); @@ -1214,19 +1565,33 @@ mod tests { let pb = &c.tables[l[1]].as_ref().unwrap().present; let ap: Vec = (0..WORDS).map(|j| mix(0xA9 ^ j as u64)).collect(); let three: [&[u64]; 3] = [pa, pb, &ap]; - assert_eq!(run_count(&and_count_program(3), &three), scalar_and(&three), "{p:?}"); + assert_eq!( + run_count(&and_count_program(3), &three), + scalar_and(&three), + "{p:?}" + ); let two: [&[u64]; 2] = [pa, pb]; - assert_eq!(run_count(&xor_count_program(), &two), scalar_xor(pa, pb), "{p:?}"); + assert_eq!( + run_count(&xor_count_program(), &two), + scalar_xor(pa, pb), + "{p:?}" + ); let or = (0..N).filter(|&i| bit(pa, i) || bit(pb, i)).count(); assert_eq!(run_count(&or_count_program(2), &two), or, "{p:?}"); // weight of one plane equals its dirty count - assert_eq!(run_count(&or_count_program(1), &[pa.as_slice()]), w.lanes[0].1.len()); + assert_eq!( + run_count(&or_count_program(1), &[pa.as_slice()]), + w.lanes[0].1.len() + ); } // the disjoint pattern really is disjoint, the overlapping one overlaps let wd = writes(Pattern::Disjoint, 0.5, 0, 4); let cd = ThoughtC::seal(&wd, Commit::Lazy); let l = touched_lanes(4); - let (a, b) = (&cd.tables[l[0]].as_ref().unwrap().present, &cd.tables[l[1]].as_ref().unwrap().present); + let (a, b) = ( + &cd.tables[l[0]].as_ref().unwrap().present, + &cd.tables[l[1]].as_ref().unwrap().present, + ); assert_eq!(scalar_and(&[a.as_slice(), b.as_slice()]), 0); assert!(scalar_xor(a, b) > 0); } @@ -1239,7 +1604,10 @@ mod tests { let pa = &c[0].tables[l[0]].as_ref().unwrap().present; let pb = &c[0].tables[l[1]].as_ref().unwrap().present; reset(); - black_box(run_count(&and_count_program(2), &[pa.as_slice(), pb.as_slice()])); + black_box(run_count( + &and_count_program(2), + &[pa.as_slice(), pb.as_slice()], + )); assert_eq!(counters(), [0; 5]); } @@ -1248,7 +1616,15 @@ mod tests { #[test] fn rows_are_built_only_by_the_terminal() { let (base, w, c) = fixture(31); - let r = resolve(&Selection { thought: 0, lanes: touched_lanes(31)[..2].to_vec(), fallback: Fallback::Base }, &c, &base); + let r = resolve( + &Selection { + thought: 0, + lanes: touched_lanes(31)[..2].to_vec(), + fallback: Fallback::Base, + }, + &c, + &base, + ); let mut out = vec![Got::Absent; 2]; reset(); for i in 0..4096 { @@ -1274,12 +1650,35 @@ mod tests { let base = base_rows(); let l = touched_lanes(1)[0]; let c: Vec = (0..2) - .map(|t| ThoughtC::seal(&Writes { thought: t, lanes: vec![(l, vec![9])] }, Commit::Lazy)) + .map(|t| { + ThoughtC::seal( + &Writes { + thought: t, + lanes: vec![(l, vec![9])], + }, + Commit::Lazy, + ) + }) .collect(); let mut out = [Got::Absent]; for t in 0..2 { - resolve(&Selection { thought: t, lanes: vec![l], fallback: Fallback::Absent }, &c, &base).read(9, &mut out); - assert_eq!(out[0], Got::Overlay { thought: t as u16, value: overlay_value(t, l, 9) }); + resolve( + &Selection { + thought: t, + lanes: vec![l], + fallback: Fallback::Absent, + }, + &c, + &base, + ) + .read(9, &mut out); + assert_eq!( + out[0], + Got::Overlay { + thought: t as u16, + value: overlay_value(t, l, 9) + } + ); } assert_ne!(overlay_value(0, l, 9), overlay_value(1, l, 9)); } @@ -1288,14 +1687,26 @@ mod tests { #[test] fn a_denied_address_loads_nothing() { let (base, _, c) = fixture(4); - let r = resolve(&Selection { thought: 0, lanes: touched_lanes(4)[..2].to_vec(), fallback: Fallback::Base }, &c, &base); + let r = resolve( + &Selection { + thought: 0, + lanes: touched_lanes(4)[..2].to_vec(), + fallback: Fallback::Base, + }, + &c, + &base, + ); let mut ap = vec![0u64; WORDS]; ap[0] = 1; // only address 0 admitted let mut out = vec![Got::Absent; 2]; reset(); r.read_under(&ap, 1, &mut out); assert_eq!(out, vec![Got::Denied; 2]); - assert_eq!(counters()[2], 0, "no value may be loaded for a denied address"); + assert_eq!( + counters()[2], + 0, + "no value may be loaded for a denied address" + ); r.read_under(&ap, 0, &mut out); assert!(out.iter().all(|g| !matches!(g, Got::Denied))); } @@ -1312,7 +1723,10 @@ mod tests { under: Some(MOp::Plane(4)), dst: 0, }], - Terminal::MaskedSumI32 { mask: MOp::Scratch(0), lane: 12 }, + Terminal::MaskedSumI32 { + mask: MOp::Scratch(0), + lane: 12, + }, ); let (planes, lanes) = lane_footprint(&p); assert_eq!(planes.into_iter().collect::>(), vec![4]); @@ -1332,7 +1746,8 @@ mod tests { assert_eq!(v.len(), 655); assert_eq!(v[v.len() - 1] - v[0], 654); let mo = writes(Pattern::Morton, 0.01, 0, 2); - let blocks: std::collections::BTreeSet = mo.lanes[0].1.iter().map(|i| i / 256).collect(); + let blocks: std::collections::BTreeSet = + mo.lanes[0].1.iter().map(|i| i / 256).collect(); assert!(blocks.len() <= 6, "morton: {} blocks", blocks.len()); assert_eq!(writes(Pattern::Uniform, 0.0, 0, 2).lanes[0].1.len(), 0); assert_eq!(writes(Pattern::Uniform, 1.0, 0, 2).lanes[0].1.len(), N); From 39488c5755745cb633c10a115004483299c3b460 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 23:37:35 +0000 Subject: [PATCH 7/9] D-HOLO H14c: v4 results; acceptance A-E met, C vs B mixed, positional tables page-dense at uniform 1 %, Lance prediction holds Results added after the unchanged pre-registration: tables consulted equal the requested lanes for every touched count (k = 2 read at U = 31 is 0.90-1.16x U = 2); populations load no value; uniform 1 % positional tables are ~93x payload resident; a scattered Lance mask cuts rows scanned but not bytes read, a clustered one cuts both; stale coordinate maps omit silently and are refused by the version check. Board entry carries the raw CSV. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .claude/board/AGENT_LOG.md | 6 + .claude/board/STATUS_BOARD.md | 2 +- .../2026-10-15-d-holo-h14c-thought-first.md | 1572 +++++++++++++++++ .claude/board/entries/README.md | 3 +- .claude/plans/d-holo-h14c-thought-first-v1.md | 294 ++- 5 files changed, 1863 insertions(+), 14 deletions(-) create mode 100644 .claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md diff --git a/.claude/board/AGENT_LOG.md b/.claude/board/AGENT_LOG.md index d0e50a981..2465a0ad6 100644 --- a/.claude/board/AGENT_LOG.md +++ b/.claude/board/AGENT_LOG.md @@ -1,3 +1,9 @@ +## 2026-10-15 — D-HOLO H14c: one Haiku census run + +- General-purpose on Haiku, read-only census of `Program::new` constructions in mask-risc tests and `lance-graph-quack` (D-HOLO-H14c-6): 169 occurrences, 61 literal, 108 dynamic; distinct lanes per literal program 0:26, 1:31, 2:4. +- Ledger: count re-run (170 raw grep hits; the one difference is `fuse.rs:216`, production code the card excluded as instructed); spot-checks 2/2 (`distinct.rs:267` P=[] L=[0,1], `reference.rs:1922` P=[3] L=[9]); 0 wrong, 0 missed. About 457k subagent tokens. +- Outcome: the census is labelled test-corpus observation in the plan; no conclusion came from the card. + ## 2026-10-15 — ledger-correction batch: two Haiku harvest runs - Card `harvest-scout` over ndarray `src/hpc/*cascade*` + blackboard (O20): hits at `cascade.rs:270-276`, `:813`, blackboard `:84-90` read and confirmed; 0 wrong, 0 missed. Earlier in the session the doc scout returned counts without hits (one miss on that kind of task). diff --git a/.claude/board/STATUS_BOARD.md b/.claude/board/STATUS_BOARD.md index acee7792a..fb76cbbca 100644 --- a/.claude/board/STATUS_BOARD.md +++ b/.claude/board/STATUS_BOARD.md @@ -43,7 +43,7 @@ Plan: `.claude/plans/relalg-v1.md`. Crate: `crates/lance-graph-relalg` (own work | **D-HOLO-H11** | Stacked logic: a chain of NAL polyfill bricks at depth 1–8 composed before one evaluation | Queued (pre-registered, not run; after H6b) | answers no single brick gives, == oracle; cost below d separate runs at d = 4; no confidence inflation, gate disable must inflate | | **D-HOLO-H12** | Semantic map of inference functions across OpenNARS, ONA, the NAL polyfill (and a MeTTa NAL if pinnable) | Queued (pre-registered, not run) | last system adds zero nodes in both orders; polyfill gaps named; differences classified as distinction or defect | | **D-HOLO-H14** | Per classid x thought x 64k tile: full 512-byte row writes vs a connected lane delta (row key + lane mask + changed lanes in one record), and per-(thought, lane) tables indexed directly by the row address (`Lane_l[index]`, no traversal; presence masks folded, materialization charged only at a terminal); session thought masks and thought lane masks kept as separate levels | Measured 2026-10-15 (v4, one class): C folds 10–256× faster than B on F1/F2; C merge-on-read 2.8–6.1× slower than B; C default and B default both not met; returned to the operator with the crossover; H14b (positional per-row lane mask for C) open | == dense reference; C default iff at k <= 4 its fold queries are >= 2x faster than B, its reads with terminal materialization <= 1.25x B and bytes <= B; else B default iff read and session read <= 1.25x A and bytes <= 0.5x A; mixed result returns to the operator | -| **D-HOLO-H14c** | Thought-first positional reads `Thought(t)[Table(a)[i] : Table(b)[i]]`: point projection, presence/Hamming populations through mask-risc, explicit terminal rows; memory and fragmentation of positional tables; Lance 13 masked I/O; coordinate identity across rewrites (sub-ids -1 … -6) | Queued (pre-registered 2026-10-15, plan d-holo-h14c-thought-first-v1; follows H14b, whose arm M is withdrawn as a layout candidate in #1569) | tables consulted == requested lanes for every touched count; at k = 2, U = 31 read <= 1.25x U = 2; populations load no value; no row materialized outside the terminal; no wrong coordinate across rewrites; Lance prediction (1 % uniform mask does not halve bytes_read, 1 % clustered does) | +| **D-HOLO-H14c** | Thought-first positional reads `Thought(t)[Table(a)[i] : Table(b)[i]]`: point projection, presence/Hamming populations through mask-risc, explicit terminal rows; memory and fragmentation of positional tables; Lance 13 masked I/O; coordinate identity across rewrites (sub-ids -1 … -6) | Measured 2026-10-15 (v4, entry 2026-10-15-d-holo-h14c-thought-first): acceptance A–E met (tables consulted == k for every U; k = 2 read at U = 31 0.90–1.16x U = 2); C vs B on query-shaped reads mixed; uniform 1 % positional tables ≈ 93x payload resident (flagged); Lance prediction holds (uniform 1 % mask 1.00x bytes, clustered 0.24x); stale maps omit silently, refused by the version check; returned to the operator | tables consulted == requested lanes for every touched count; at k = 2, U = 31 read <= 1.25x U = 2; populations load no value; no row materialized outside the terminal; no wrong coordinate across rewrites; Lance prediction (1 % uniform mask does not halve bytes_read, 1 % clustered does) | | **D-RA-1** | `Rel` + `normalize` + `symbolic` + R2IL lowering | Shipped #1546 `c21bd165` (11 tests, 11 disable runs red; four comparisons on one lane 8 → 2 ops; 70/2,000 small descriptions refused as written, all run rewritten) | == row oracle over 400 generated descriptions × 5 measures | | **D-RA-2** | Rules into the contract set IR (D-CMR-1/-6); relalg keeps only lowering or is deleted | Queued (maintainer decision) | relalg tests pass unchanged against the contract IR | | **D-RA-3** | Datalog rules as algebra values; names are labels resolved through the label codebook, never strings in a rule | Queued (after D-RA-2) | codebook-built rules == hand-written `Rel`; unknown label refused at resolution | diff --git a/.claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md b/.claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md new file mode 100644 index 000000000..32035c82d --- /dev/null +++ b/.claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md @@ -0,0 +1,1572 @@ +# D-HOLO-H14c — thought-first positional reads, Hamming presence, Lance 13 masked I/O (v4, 2026-10-15) + +**Status:** MEASURED. Plan: `.claude/plans/d-holo-h14c-thought-first-v1.md` (pre-registered before the run; results there). +**Probes:** `crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs`; `crates/holo-lance-masked-io-probe` (excluded from the workspace). `tier: v4 (avx512f)`, rustc 1.99.0, lance 13.0.0. + +- Acceptance A–E met: a read consults exactly the requested lane tables + (counter == k for U = 2, 8, 31); at k = 2 the read at U = 31 costs + 0.90–1.01× (hot) and 0.95–1.16× (cold) the read at U = 2; populations load + no value; no row is built outside the terminal; every rewrite scenario + returns the requested coordinates or refuses. +- C vs B on query-shaped reads is mixed: B faster hot at ≤ 1 % dirty (one row + index vs k presence tests); C faster cold from 10 % at k ≤ 8; B faster at + k ≥ 16 in most cells. Sparse binary search is slowest. +- Positional tables are resident at about one page per touched page: uniform + 1 % costs ≈ 955 KiB per table for ≈ 10 KiB of values (flagged, every T); + clustered 1 % costs 62 KiB. Seal is page-fault bound at low density. +- Lance 13 prediction holds: a uniform 1 % mask reads the same bytes as no + mask (ratio 1.00) while rows scanned drop to 692 of 65,536; clustered 1 % + reads 0.24×. Materialization style changed bytes in 0 of 120 cells. +- A stale coordinate map gives silent omission, not wrong coordinates; + stable row ids keep `_rowid` across update and compaction (0 moved), not + across overwrite. The version check refuses all six stale cases. + +**OPEN:** bounding positional-table residency without traversal; stable row +ids for lane datasets; page-local presence for scattered masks. No hardware +counters on this VM (cache/TLB measured indirectly). + +## Raw data (machine-readable) + +Columns, in-memory probe: `csv,section,arm,pattern,density,T,U,k,cache,metric,value` +(section A point, B population, C terminal, M memory). Lance probe: +`csv,strategy,pattern,density,k,style,rows_emitted,bytes_read,iops,requests,rows_scanned,ranges_scanned,wall_us`. +Memory rows come from the per-cell child-process run; the first run's memory +rows were discarded (allocator reuse zeroed their deltas). + +```csv +csv,section,arm,pattern,density,T,U,k,cache,metric,value +csv,A,C,uniform,0,1,1,1,-,resolve_ns,41.914 +csv,A,C,uniform,0,1,1,1,hot,read_ns,14.690 +csv,A,B,uniform,0,1,1,1,hot,read_ns,11.579 +csv,A,S,uniform,0,1,1,1,hot,read_ns,12.120 +csv,A,C,uniform,0,1,1,1,cold,read_ns,103.703 +csv,A,B,uniform,0,1,1,1,cold,read_ns,105.167 +csv,A,S,uniform,0,1,1,1,cold,read_ns,117.344 +csv,A,C,uniform,0,1,2,2,-,resolve_ns,26.544 +csv,A,C,uniform,0,1,2,2,hot,read_ns,16.233 +csv,A,B,uniform,0,1,2,2,hot,read_ns,10.214 +csv,A,S,uniform,0,1,2,2,hot,read_ns,14.761 +csv,A,C,uniform,0,1,2,2,cold,read_ns,164.008 +csv,A,B,uniform,0,1,2,2,cold,read_ns,126.295 +csv,A,S,uniform,0,1,2,2,cold,read_ns,149.760 +csv,B,C,uniform,0,1,2,2,hot,shared_ns_per_word,0.418 +csv,B,C,uniform,0,1,2,2,hot,hamming_ns_per_word,0.356 +csv,B,C,uniform,0,1,2,2,-,shared_count,0.000 +csv,A,C,uniform,0,1,4,4,-,resolve_ns,29.506 +csv,A,C,uniform,0,1,4,4,hot,read_ns,28.940 +csv,A,B,uniform,0,1,4,4,hot,read_ns,15.671 +csv,A,S,uniform,0,1,4,4,hot,read_ns,27.058 +csv,A,C,uniform,0,1,4,4,cold,read_ns,181.125 +csv,A,B,uniform,0,1,4,4,cold,read_ns,155.846 +csv,A,S,uniform,0,1,4,4,cold,read_ns,167.755 +csv,B,C,uniform,0,1,4,2,hot,shared_ns_per_word,0.932 +csv,B,C,uniform,0,1,4,2,hot,hamming_ns_per_word,0.920 +csv,B,C,uniform,0,1,4,2,-,shared_count,0.000 +csv,A,C,uniform,0,1,8,1,-,resolve_ns,30.538 +csv,A,C,uniform,0,1,8,1,hot,read_ns,10.019 +csv,A,B,uniform,0,1,8,1,hot,read_ns,7.092 +csv,A,S,uniform,0,1,8,1,hot,read_ns,8.297 +csv,A,C,uniform,0,1,8,1,cold,read_ns,109.391 +csv,A,B,uniform,0,1,8,1,cold,read_ns,107.206 +csv,A,S,uniform,0,1,8,1,cold,read_ns,104.953 +csv,A,C,uniform,0,1,8,2,-,resolve_ns,28.213 +csv,A,C,uniform,0,1,8,2,hot,read_ns,16.232 +csv,A,B,uniform,0,1,8,2,hot,read_ns,10.215 +csv,A,S,uniform,0,1,8,2,hot,read_ns,14.604 +csv,A,C,uniform,0,1,8,2,cold,read_ns,151.760 +csv,A,B,uniform,0,1,8,2,cold,read_ns,118.033 +csv,A,S,uniform,0,1,8,2,cold,read_ns,161.114 +csv,A,C,uniform,0,1,8,4,-,resolve_ns,31.691 +csv,A,C,uniform,0,1,8,4,hot,read_ns,34.884 +csv,A,B,uniform,0,1,8,4,hot,read_ns,18.877 +csv,A,S,uniform,0,1,8,4,hot,read_ns,29.447 +csv,A,C,uniform,0,1,8,4,cold,read_ns,194.226 +csv,A,B,uniform,0,1,8,4,cold,read_ns,178.825 +csv,A,S,uniform,0,1,8,4,cold,read_ns,177.273 +csv,A,C,uniform,0,1,8,8,-,resolve_ns,34.003 +csv,A,C,uniform,0,1,8,8,hot,read_ns,54.232 +csv,A,B,uniform,0,1,8,8,hot,read_ns,21.934 +csv,A,S,uniform,0,1,8,8,hot,read_ns,53.662 +csv,A,C,uniform,0,1,8,8,cold,read_ns,309.873 +csv,A,B,uniform,0,1,8,8,cold,read_ns,223.243 +csv,A,S,uniform,0,1,8,8,cold,read_ns,353.870 +csv,B,C,uniform,0,1,8,2,hot,shared_ns_per_word,0.979 +csv,B,C,uniform,0,1,8,2,hot,hamming_ns_per_word,0.917 +csv,B,C,uniform,0,1,8,2,-,shared_count,0.000 +csv,A,C,uniform,0,1,16,16,-,resolve_ns,53.751 +csv,A,C,uniform,0,1,16,16,hot,read_ns,109.066 +csv,A,B,uniform,0,1,16,16,hot,read_ns,35.836 +csv,A,S,uniform,0,1,16,16,hot,read_ns,118.702 +csv,A,C,uniform,0,1,16,16,cold,read_ns,574.597 +csv,A,B,uniform,0,1,16,16,cold,read_ns,320.745 +csv,A,S,uniform,0,1,16,16,cold,read_ns,466.364 +csv,B,C,uniform,0,1,16,2,hot,shared_ns_per_word,0.947 +csv,B,C,uniform,0,1,16,2,hot,hamming_ns_per_word,0.965 +csv,B,C,uniform,0,1,16,2,-,shared_count,0.000 +csv,A,C,uniform,0,1,31,1,-,resolve_ns,25.805 +csv,A,C,uniform,0,1,31,1,hot,read_ns,10.023 +csv,A,B,uniform,0,1,31,1,hot,read_ns,7.094 +csv,A,S,uniform,0,1,31,1,hot,read_ns,8.304 +csv,A,C,uniform,0,1,31,1,cold,read_ns,105.468 +csv,A,B,uniform,0,1,31,1,cold,read_ns,105.525 +csv,A,S,uniform,0,1,31,1,cold,read_ns,93.611 +csv,A,C,uniform,0,1,31,2,-,resolve_ns,28.294 +csv,A,C,uniform,0,1,31,2,hot,read_ns,16.414 +csv,A,B,uniform,0,1,31,2,hot,read_ns,9.998 +csv,A,S,uniform,0,1,31,2,hot,read_ns,14.628 +csv,A,C,uniform,0,1,31,2,cold,read_ns,161.141 +csv,A,B,uniform,0,1,31,2,cold,read_ns,119.846 +csv,A,S,uniform,0,1,31,2,cold,read_ns,129.922 +csv,A,C,uniform,0,1,31,4,-,resolve_ns,31.430 +csv,A,C,uniform,0,1,31,4,hot,read_ns,28.979 +csv,A,B,uniform,0,1,31,4,hot,read_ns,15.702 +csv,A,S,uniform,0,1,31,4,hot,read_ns,27.259 +csv,A,C,uniform,0,1,31,4,cold,read_ns,156.893 +csv,A,B,uniform,0,1,31,4,cold,read_ns,149.484 +csv,A,S,uniform,0,1,31,4,cold,read_ns,180.816 +csv,A,C,uniform,0,1,31,8,-,resolve_ns,34.959 +csv,A,C,uniform,0,1,31,8,hot,read_ns,58.150 +csv,A,B,uniform,0,1,31,8,hot,read_ns,35.284 +csv,A,S,uniform,0,1,31,8,hot,read_ns,56.315 +csv,A,C,uniform,0,1,31,8,cold,read_ns,298.108 +csv,A,B,uniform,0,1,31,8,cold,read_ns,211.920 +csv,A,S,uniform,0,1,31,8,cold,read_ns,298.215 +csv,A,C,uniform,0,1,31,16,-,resolve_ns,44.157 +csv,A,C,uniform,0,1,31,16,hot,read_ns,107.826 +csv,A,B,uniform,0,1,31,16,hot,read_ns,33.998 +csv,A,S,uniform,0,1,31,16,hot,read_ns,104.052 +csv,A,C,uniform,0,1,31,16,cold,read_ns,462.462 +csv,A,B,uniform,0,1,31,16,cold,read_ns,320.516 +csv,A,S,uniform,0,1,31,16,cold,read_ns,439.636 +csv,A,C,uniform,0,1,31,31,-,resolve_ns,129.161 +csv,A,C,uniform,0,1,31,31,hot,read_ns,215.143 +csv,A,B,uniform,0,1,31,31,hot,read_ns,61.561 +csv,A,S,uniform,0,1,31,31,hot,read_ns,202.258 +csv,A,C,uniform,0,1,31,31,cold,read_ns,688.510 +csv,A,B,uniform,0,1,31,31,cold,read_ns,470.548 +csv,A,S,uniform,0,1,31,31,cold,read_ns,698.050 +csv,B,C,uniform,0,1,31,2,hot,shared_ns_per_word,0.995 +csv,B,C,uniform,0,1,31,2,hot,hamming_ns_per_word,0.946 +csv,B,C,uniform,0,1,31,2,-,shared_count,0.000 +csv,C,C,uniform,0,1,31,31,hot,row_ns,95.647 +csv,A,C,uniform,0.001,1,1,1,-,resolve_ns,26.985 +csv,A,C,uniform,0.001,1,1,1,hot,read_ns,16.795 +csv,A,B,uniform,0.001,1,1,1,hot,read_ns,12.384 +csv,A,S,uniform,0.001,1,1,1,hot,read_ns,17.070 +csv,A,C,uniform,0.001,1,1,1,cold,read_ns,111.547 +csv,A,B,uniform,0.001,1,1,1,cold,read_ns,101.968 +csv,A,S,uniform,0.001,1,1,1,cold,read_ns,150.368 +csv,A,C,uniform,0.001,1,2,2,-,resolve_ns,27.687 +csv,A,C,uniform,0.001,1,2,2,hot,read_ns,16.270 +csv,A,B,uniform,0.001,1,2,2,hot,read_ns,10.214 +csv,A,S,uniform,0.001,1,2,2,hot,read_ns,29.035 +csv,A,C,uniform,0.001,1,2,2,cold,read_ns,164.392 +csv,A,B,uniform,0.001,1,2,2,cold,read_ns,120.518 +csv,A,S,uniform,0.001,1,2,2,cold,read_ns,254.341 +csv,B,C,uniform,0.001,1,2,2,hot,shared_ns_per_word,0.938 +csv,B,C,uniform,0.001,1,2,2,hot,hamming_ns_per_word,0.944 +csv,B,C,uniform,0.001,1,2,2,-,shared_count,0.000 +csv,A,C,uniform,0.001,1,4,4,-,resolve_ns,28.895 +csv,A,C,uniform,0.001,1,4,4,hot,read_ns,28.811 +csv,A,B,uniform,0.001,1,4,4,hot,read_ns,15.729 +csv,A,S,uniform,0.001,1,4,4,hot,read_ns,57.268 +csv,A,C,uniform,0.001,1,4,4,cold,read_ns,172.006 +csv,A,B,uniform,0.001,1,4,4,cold,read_ns,189.925 +csv,A,S,uniform,0.001,1,4,4,cold,read_ns,323.398 +csv,B,C,uniform,0.001,1,4,2,hot,shared_ns_per_word,0.964 +csv,B,C,uniform,0.001,1,4,2,hot,hamming_ns_per_word,0.933 +csv,B,C,uniform,0.001,1,4,2,-,shared_count,0.000 +csv,A,C,uniform,0.001,1,8,1,-,resolve_ns,25.479 +csv,A,C,uniform,0.001,1,8,1,hot,read_ns,10.252 +csv,A,B,uniform,0.001,1,8,1,hot,read_ns,7.154 +csv,A,S,uniform,0.001,1,8,1,hot,read_ns,25.236 +csv,A,C,uniform,0.001,1,8,1,cold,read_ns,108.036 +csv,A,B,uniform,0.001,1,8,1,cold,read_ns,103.361 +csv,A,S,uniform,0.001,1,8,1,cold,read_ns,144.787 +csv,A,C,uniform,0.001,1,8,2,-,resolve_ns,26.759 +csv,A,C,uniform,0.001,1,8,2,hot,read_ns,16.578 +csv,A,B,uniform,0.001,1,8,2,hot,read_ns,10.287 +csv,A,S,uniform,0.001,1,8,2,hot,read_ns,29.039 +csv,A,C,uniform,0.001,1,8,2,cold,read_ns,151.092 +csv,A,B,uniform,0.001,1,8,2,cold,read_ns,119.085 +csv,A,S,uniform,0.001,1,8,2,cold,read_ns,251.748 +csv,A,C,uniform,0.001,1,8,4,-,resolve_ns,30.615 +csv,A,C,uniform,0.001,1,8,4,hot,read_ns,29.112 +csv,A,B,uniform,0.001,1,8,4,hot,read_ns,15.788 +csv,A,S,uniform,0.001,1,8,4,hot,read_ns,57.056 +csv,A,C,uniform,0.001,1,8,4,cold,read_ns,183.268 +csv,A,B,uniform,0.001,1,8,4,cold,read_ns,162.200 +csv,A,S,uniform,0.001,1,8,4,cold,read_ns,288.234 +csv,A,C,uniform,0.001,1,8,8,-,resolve_ns,38.823 +csv,A,C,uniform,0.001,1,8,8,hot,read_ns,56.071 +csv,A,B,uniform,0.001,1,8,8,hot,read_ns,21.205 +csv,A,S,uniform,0.001,1,8,8,hot,read_ns,109.534 +csv,A,C,uniform,0.001,1,8,8,cold,read_ns,298.540 +csv,A,B,uniform,0.001,1,8,8,cold,read_ns,197.977 +csv,A,S,uniform,0.001,1,8,8,cold,read_ns,510.117 +csv,B,C,uniform,0.001,1,8,2,hot,shared_ns_per_word,0.945 +csv,B,C,uniform,0.001,1,8,2,hot,hamming_ns_per_word,0.932 +csv,B,C,uniform,0.001,1,8,2,-,shared_count,0.000 +csv,A,C,uniform,0.001,1,16,16,-,resolve_ns,44.449 +csv,A,C,uniform,0.001,1,16,16,hot,read_ns,105.521 +csv,A,B,uniform,0.001,1,16,16,hot,read_ns,35.670 +csv,A,S,uniform,0.001,1,16,16,hot,read_ns,222.386 +csv,A,C,uniform,0.001,1,16,16,cold,read_ns,407.067 +csv,A,B,uniform,0.001,1,16,16,cold,read_ns,308.275 +csv,A,S,uniform,0.001,1,16,16,cold,read_ns,736.146 +csv,B,C,uniform,0.001,1,16,2,hot,shared_ns_per_word,0.925 +csv,B,C,uniform,0.001,1,16,2,hot,hamming_ns_per_word,0.931 +csv,B,C,uniform,0.001,1,16,2,-,shared_count,0.000 +csv,A,C,uniform,0.001,1,31,1,-,resolve_ns,25.557 +csv,A,C,uniform,0.001,1,31,1,hot,read_ns,10.031 +csv,A,B,uniform,0.001,1,31,1,hot,read_ns,7.395 +csv,A,S,uniform,0.001,1,31,1,hot,read_ns,16.590 +csv,A,C,uniform,0.001,1,31,1,cold,read_ns,107.230 +csv,A,B,uniform,0.001,1,31,1,cold,read_ns,103.193 +csv,A,S,uniform,0.001,1,31,1,cold,read_ns,130.133 +csv,A,C,uniform,0.001,1,31,2,-,resolve_ns,28.067 +csv,A,C,uniform,0.001,1,31,2,hot,read_ns,16.239 +csv,A,B,uniform,0.001,1,31,2,hot,read_ns,10.525 +csv,A,S,uniform,0.001,1,31,2,hot,read_ns,29.180 +csv,A,C,uniform,0.001,1,31,2,cold,read_ns,158.293 +csv,A,B,uniform,0.001,1,31,2,cold,read_ns,124.783 +csv,A,S,uniform,0.001,1,31,2,cold,read_ns,265.455 +csv,A,C,uniform,0.001,1,31,4,-,resolve_ns,32.469 +csv,A,C,uniform,0.001,1,31,4,hot,read_ns,29.300 +csv,A,B,uniform,0.001,1,31,4,hot,read_ns,14.576 +csv,A,S,uniform,0.001,1,31,4,hot,read_ns,56.584 +csv,A,C,uniform,0.001,1,31,4,cold,read_ns,184.604 +csv,A,B,uniform,0.001,1,31,4,cold,read_ns,157.862 +csv,A,S,uniform,0.001,1,31,4,cold,read_ns,291.872 +csv,A,C,uniform,0.001,1,31,8,-,resolve_ns,34.514 +csv,A,C,uniform,0.001,1,31,8,hot,read_ns,56.059 +csv,A,B,uniform,0.001,1,31,8,hot,read_ns,21.615 +csv,A,S,uniform,0.001,1,31,8,hot,read_ns,109.915 +csv,A,C,uniform,0.001,1,31,8,cold,read_ns,281.712 +csv,A,B,uniform,0.001,1,31,8,cold,read_ns,213.946 +csv,A,S,uniform,0.001,1,31,8,cold,read_ns,477.956 +csv,A,C,uniform,0.001,1,31,16,-,resolve_ns,44.266 +csv,A,C,uniform,0.001,1,31,16,hot,read_ns,107.580 +csv,A,B,uniform,0.001,1,31,16,hot,read_ns,42.754 +csv,A,S,uniform,0.001,1,31,16,hot,read_ns,235.869 +csv,A,C,uniform,0.001,1,31,16,cold,read_ns,399.372 +csv,A,B,uniform,0.001,1,31,16,cold,read_ns,326.465 +csv,A,S,uniform,0.001,1,31,16,cold,read_ns,720.516 +csv,A,C,uniform,0.001,1,31,31,-,resolve_ns,61.965 +csv,A,C,uniform,0.001,1,31,31,hot,read_ns,207.000 +csv,A,B,uniform,0.001,1,31,31,hot,read_ns,60.921 +csv,A,S,uniform,0.001,1,31,31,hot,read_ns,434.325 +csv,A,C,uniform,0.001,1,31,31,cold,read_ns,600.084 +csv,A,B,uniform,0.001,1,31,31,cold,read_ns,419.497 +csv,A,S,uniform,0.001,1,31,31,cold,read_ns,1115.263 +csv,B,C,uniform,0.001,1,31,2,hot,shared_ns_per_word,0.968 +csv,B,C,uniform,0.001,1,31,2,hot,hamming_ns_per_word,0.916 +csv,B,C,uniform,0.001,1,31,2,-,shared_count,0.000 +csv,C,C,uniform,0.001,1,31,31,hot,row_ns,104.978 +csv,A,C,uniform,0.01,1,1,1,-,resolve_ns,25.467 +csv,A,C,uniform,0.01,1,1,1,hot,read_ns,10.047 +csv,A,B,uniform,0.01,1,1,1,hot,read_ns,7.268 +csv,A,S,uniform,0.01,1,1,1,hot,read_ns,23.606 +csv,A,C,uniform,0.01,1,1,1,cold,read_ns,102.961 +csv,A,B,uniform,0.01,1,1,1,cold,read_ns,114.621 +csv,A,S,uniform,0.01,1,1,1,cold,read_ns,165.699 +csv,A,C,uniform,0.01,1,2,2,-,resolve_ns,27.917 +csv,A,C,uniform,0.01,1,2,2,hot,read_ns,16.529 +csv,A,B,uniform,0.01,1,2,2,hot,read_ns,10.438 +csv,A,S,uniform,0.01,1,2,2,hot,read_ns,42.474 +csv,A,C,uniform,0.01,1,2,2,cold,read_ns,165.007 +csv,A,B,uniform,0.01,1,2,2,cold,read_ns,119.330 +csv,A,S,uniform,0.01,1,2,2,cold,read_ns,306.074 +csv,B,C,uniform,0.01,1,2,2,hot,shared_ns_per_word,0.965 +csv,B,C,uniform,0.01,1,2,2,hot,hamming_ns_per_word,0.932 +csv,B,C,uniform,0.01,1,2,2,-,shared_count,7.000 +csv,A,C,uniform,0.01,1,4,4,-,resolve_ns,278.632 +csv,A,C,uniform,0.01,1,4,4,hot,read_ns,28.787 +csv,A,B,uniform,0.01,1,4,4,hot,read_ns,14.867 +csv,A,S,uniform,0.01,1,4,4,hot,read_ns,79.434 +csv,A,C,uniform,0.01,1,4,4,cold,read_ns,194.352 +csv,A,B,uniform,0.01,1,4,4,cold,read_ns,170.615 +csv,A,S,uniform,0.01,1,4,4,cold,read_ns,331.961 +csv,B,C,uniform,0.01,1,4,2,hot,shared_ns_per_word,0.924 +csv,B,C,uniform,0.01,1,4,2,hot,hamming_ns_per_word,0.964 +csv,B,C,uniform,0.01,1,4,2,-,shared_count,7.000 +csv,A,C,uniform,0.01,1,8,1,-,resolve_ns,25.630 +csv,A,C,uniform,0.01,1,8,1,hot,read_ns,10.056 +csv,A,B,uniform,0.01,1,8,1,hot,read_ns,7.860 +csv,A,S,uniform,0.01,1,8,1,hot,read_ns,23.951 +csv,A,C,uniform,0.01,1,8,1,cold,read_ns,108.725 +csv,A,B,uniform,0.01,1,8,1,cold,read_ns,107.638 +csv,A,S,uniform,0.01,1,8,1,cold,read_ns,149.628 +csv,A,C,uniform,0.01,1,8,2,-,resolve_ns,28.141 +csv,A,C,uniform,0.01,1,8,2,hot,read_ns,16.210 +csv,A,B,uniform,0.01,1,8,2,hot,read_ns,11.111 +csv,A,S,uniform,0.01,1,8,2,hot,read_ns,43.034 +csv,A,C,uniform,0.01,1,8,2,cold,read_ns,154.342 +csv,A,B,uniform,0.01,1,8,2,cold,read_ns,132.639 +csv,A,S,uniform,0.01,1,8,2,cold,read_ns,455.350 +csv,A,C,uniform,0.01,1,8,4,-,resolve_ns,56.695 +csv,A,C,uniform,0.01,1,8,4,hot,read_ns,35.247 +csv,A,B,uniform,0.01,1,8,4,hot,read_ns,24.293 +csv,A,S,uniform,0.01,1,8,4,hot,read_ns,124.321 +csv,A,C,uniform,0.01,1,8,4,cold,read_ns,195.199 +csv,A,B,uniform,0.01,1,8,4,cold,read_ns,174.795 +csv,A,S,uniform,0.01,1,8,4,cold,read_ns,327.054 +csv,A,C,uniform,0.01,1,8,8,-,resolve_ns,33.594 +csv,A,C,uniform,0.01,1,8,8,hot,read_ns,53.322 +csv,A,B,uniform,0.01,1,8,8,hot,read_ns,22.773 +csv,A,S,uniform,0.01,1,8,8,hot,read_ns,158.786 +csv,A,C,uniform,0.01,1,8,8,cold,read_ns,309.079 +csv,A,B,uniform,0.01,1,8,8,cold,read_ns,217.922 +csv,A,S,uniform,0.01,1,8,8,cold,read_ns,547.211 +csv,B,C,uniform,0.01,1,8,2,hot,shared_ns_per_word,0.967 +csv,B,C,uniform,0.01,1,8,2,hot,hamming_ns_per_word,0.938 +csv,B,C,uniform,0.01,1,8,2,-,shared_count,7.000 +csv,A,C,uniform,0.01,1,16,16,-,resolve_ns,43.891 +csv,A,C,uniform,0.01,1,16,16,hot,read_ns,106.163 +csv,A,B,uniform,0.01,1,16,16,hot,read_ns,44.323 +csv,A,S,uniform,0.01,1,16,16,hot,read_ns,328.666 +csv,A,C,uniform,0.01,1,16,16,cold,read_ns,428.346 +csv,A,B,uniform,0.01,1,16,16,cold,read_ns,357.143 +csv,A,S,uniform,0.01,1,16,16,cold,read_ns,910.518 +csv,B,C,uniform,0.01,1,16,2,hot,shared_ns_per_word,0.928 +csv,B,C,uniform,0.01,1,16,2,hot,hamming_ns_per_word,0.941 +csv,B,C,uniform,0.01,1,16,2,-,shared_count,7.000 +csv,A,C,uniform,0.01,1,31,1,-,resolve_ns,26.234 +csv,A,C,uniform,0.01,1,31,1,hot,read_ns,10.051 +csv,A,B,uniform,0.01,1,31,1,hot,read_ns,8.540 +csv,A,S,uniform,0.01,1,31,1,hot,read_ns,23.949 +csv,A,C,uniform,0.01,1,31,1,cold,read_ns,102.336 +csv,A,B,uniform,0.01,1,31,1,cold,read_ns,113.857 +csv,A,S,uniform,0.01,1,31,1,cold,read_ns,156.216 +csv,A,C,uniform,0.01,1,31,2,-,resolve_ns,32.893 +csv,A,C,uniform,0.01,1,31,2,hot,read_ns,16.221 +csv,A,B,uniform,0.01,1,31,2,hot,read_ns,12.202 +csv,A,S,uniform,0.01,1,31,2,hot,read_ns,43.384 +csv,A,C,uniform,0.01,1,31,2,cold,read_ns,157.341 +csv,A,B,uniform,0.01,1,31,2,cold,read_ns,158.982 +csv,A,S,uniform,0.01,1,31,2,cold,read_ns,263.301 +csv,A,C,uniform,0.01,1,31,4,-,resolve_ns,30.484 +csv,A,C,uniform,0.01,1,31,4,hot,read_ns,29.233 +csv,A,B,uniform,0.01,1,31,4,hot,read_ns,17.416 +csv,A,S,uniform,0.01,1,31,4,hot,read_ns,81.713 +csv,A,C,uniform,0.01,1,31,4,cold,read_ns,190.356 +csv,A,B,uniform,0.01,1,31,4,cold,read_ns,187.583 +csv,A,S,uniform,0.01,1,31,4,cold,read_ns,355.328 +csv,A,C,uniform,0.01,1,31,8,-,resolve_ns,34.309 +csv,A,C,uniform,0.01,1,31,8,hot,read_ns,55.722 +csv,A,B,uniform,0.01,1,31,8,hot,read_ns,29.210 +csv,A,S,uniform,0.01,1,31,8,hot,read_ns,159.740 +csv,A,C,uniform,0.01,1,31,8,cold,read_ns,371.228 +csv,A,B,uniform,0.01,1,31,8,cold,read_ns,237.304 +csv,A,S,uniform,0.01,1,31,8,cold,read_ns,533.676 +csv,A,C,uniform,0.01,1,31,16,-,resolve_ns,44.252 +csv,A,C,uniform,0.01,1,31,16,hot,read_ns,112.432 +csv,A,B,uniform,0.01,1,31,16,hot,read_ns,50.463 +csv,A,S,uniform,0.01,1,31,16,hot,read_ns,345.110 +csv,A,C,uniform,0.01,1,31,16,cold,read_ns,433.800 +csv,A,B,uniform,0.01,1,31,16,cold,read_ns,366.605 +csv,A,S,uniform,0.01,1,31,16,cold,read_ns,1014.676 +csv,A,C,uniform,0.01,1,31,31,-,resolve_ns,60.716 +csv,A,C,uniform,0.01,1,31,31,hot,read_ns,271.674 +csv,A,B,uniform,0.01,1,31,31,hot,read_ns,129.521 +csv,A,S,uniform,0.01,1,31,31,hot,read_ns,823.070 +csv,A,C,uniform,0.01,1,31,31,cold,read_ns,718.199 +csv,A,B,uniform,0.01,1,31,31,cold,read_ns,498.226 +csv,A,S,uniform,0.01,1,31,31,cold,read_ns,1332.243 +csv,B,C,uniform,0.01,1,31,2,hot,shared_ns_per_word,0.974 +csv,B,C,uniform,0.01,1,31,2,hot,hamming_ns_per_word,0.389 +csv,B,C,uniform,0.01,1,31,2,-,shared_count,7.000 +csv,C,C,uniform,0.01,1,31,31,hot,row_ns,100.012 +csv,A,C,uniform,0.1,1,1,1,-,resolve_ns,25.574 +csv,A,C,uniform,0.1,1,1,1,hot,read_ns,10.157 +csv,A,B,uniform,0.1,1,1,1,hot,read_ns,8.190 +csv,A,S,uniform,0.1,1,1,1,hot,read_ns,32.342 +csv,A,C,uniform,0.1,1,1,1,cold,read_ns,96.634 +csv,A,B,uniform,0.1,1,1,1,cold,read_ns,104.058 +csv,A,S,uniform,0.1,1,1,1,cold,read_ns,230.188 +csv,A,C,uniform,0.1,1,2,2,-,resolve_ns,33.697 +csv,A,C,uniform,0.1,1,2,2,hot,read_ns,16.030 +csv,A,B,uniform,0.1,1,2,2,hot,read_ns,12.538 +csv,A,S,uniform,0.1,1,2,2,hot,read_ns,66.300 +csv,A,C,uniform,0.1,1,2,2,cold,read_ns,152.239 +csv,A,B,uniform,0.1,1,2,2,cold,read_ns,127.849 +csv,A,S,uniform,0.1,1,2,2,cold,read_ns,299.949 +csv,B,C,uniform,0.1,1,2,2,hot,shared_ns_per_word,0.950 +csv,B,C,uniform,0.1,1,2,2,hot,hamming_ns_per_word,0.934 +csv,B,C,uniform,0.1,1,2,2,-,shared_count,671.000 +csv,A,C,uniform,0.1,1,4,4,-,resolve_ns,28.743 +csv,A,C,uniform,0.1,1,4,4,hot,read_ns,27.739 +csv,A,B,uniform,0.1,1,4,4,hot,read_ns,18.344 +csv,A,S,uniform,0.1,1,4,4,hot,read_ns,132.636 +csv,A,C,uniform,0.1,1,4,4,cold,read_ns,194.422 +csv,A,B,uniform,0.1,1,4,4,cold,read_ns,208.183 +csv,A,S,uniform,0.1,1,4,4,cold,read_ns,442.710 +csv,B,C,uniform,0.1,1,4,2,hot,shared_ns_per_word,0.944 +csv,B,C,uniform,0.1,1,4,2,hot,hamming_ns_per_word,0.936 +csv,B,C,uniform,0.1,1,4,2,-,shared_count,671.000 +csv,A,C,uniform,0.1,1,8,1,-,resolve_ns,25.913 +csv,A,C,uniform,0.1,1,8,1,hot,read_ns,10.178 +csv,A,B,uniform,0.1,1,8,1,hot,read_ns,9.986 +csv,A,S,uniform,0.1,1,8,1,hot,read_ns,32.785 +csv,A,C,uniform,0.1,1,8,1,cold,read_ns,106.515 +csv,A,B,uniform,0.1,1,8,1,cold,read_ns,128.409 +csv,A,S,uniform,0.1,1,8,1,cold,read_ns,244.981 +csv,A,C,uniform,0.1,1,8,2,-,resolve_ns,28.286 +csv,A,C,uniform,0.1,1,8,2,hot,read_ns,16.045 +csv,A,B,uniform,0.1,1,8,2,hot,read_ns,14.122 +csv,A,S,uniform,0.1,1,8,2,hot,read_ns,64.764 +csv,A,C,uniform,0.1,1,8,2,cold,read_ns,158.353 +csv,A,B,uniform,0.1,1,8,2,cold,read_ns,164.185 +csv,A,S,uniform,0.1,1,8,2,cold,read_ns,289.347 +csv,A,C,uniform,0.1,1,8,4,-,resolve_ns,32.288 +csv,A,C,uniform,0.1,1,8,4,hot,read_ns,27.284 +csv,A,B,uniform,0.1,1,8,4,hot,read_ns,19.978 +csv,A,S,uniform,0.1,1,8,4,hot,read_ns,136.526 +csv,A,C,uniform,0.1,1,8,4,cold,read_ns,199.701 +csv,A,B,uniform,0.1,1,8,4,cold,read_ns,211.933 +csv,A,S,uniform,0.1,1,8,4,cold,read_ns,409.784 +csv,A,C,uniform,0.1,1,8,8,-,resolve_ns,34.152 +csv,A,C,uniform,0.1,1,8,8,hot,read_ns,52.298 +csv,A,B,uniform,0.1,1,8,8,hot,read_ns,33.061 +csv,A,S,uniform,0.1,1,8,8,hot,read_ns,290.337 +csv,A,C,uniform,0.1,1,8,8,cold,read_ns,329.415 +csv,A,B,uniform,0.1,1,8,8,cold,read_ns,317.740 +csv,A,S,uniform,0.1,1,8,8,cold,read_ns,702.913 +csv,B,C,uniform,0.1,1,8,2,hot,shared_ns_per_word,0.956 +csv,B,C,uniform,0.1,1,8,2,hot,hamming_ns_per_word,0.939 +csv,B,C,uniform,0.1,1,8,2,-,shared_count,671.000 +csv,A,C,uniform,0.1,1,16,16,-,resolve_ns,49.685 +csv,A,C,uniform,0.1,1,16,16,hot,read_ns,101.012 +csv,A,B,uniform,0.1,1,16,16,hot,read_ns,75.048 +csv,A,S,uniform,0.1,1,16,16,hot,read_ns,646.037 +csv,A,C,uniform,0.1,1,16,16,cold,read_ns,485.522 +csv,A,B,uniform,0.1,1,16,16,cold,read_ns,515.824 +csv,A,S,uniform,0.1,1,16,16,cold,read_ns,1334.727 +csv,B,C,uniform,0.1,1,16,2,hot,shared_ns_per_word,0.922 +csv,B,C,uniform,0.1,1,16,2,hot,hamming_ns_per_word,0.928 +csv,B,C,uniform,0.1,1,16,2,-,shared_count,671.000 +csv,A,C,uniform,0.1,1,31,1,-,resolve_ns,25.690 +csv,A,C,uniform,0.1,1,31,1,hot,read_ns,10.211 +csv,A,B,uniform,0.1,1,31,1,hot,read_ns,13.023 +csv,A,S,uniform,0.1,1,31,1,hot,read_ns,32.427 +csv,A,C,uniform,0.1,1,31,1,cold,read_ns,106.331 +csv,A,B,uniform,0.1,1,31,1,cold,read_ns,155.539 +csv,A,S,uniform,0.1,1,31,1,cold,read_ns,248.971 +csv,A,C,uniform,0.1,1,31,2,-,resolve_ns,32.464 +csv,A,C,uniform,0.1,1,31,2,hot,read_ns,16.230 +csv,A,B,uniform,0.1,1,31,2,hot,read_ns,17.454 +csv,A,S,uniform,0.1,1,31,2,hot,read_ns,64.786 +csv,A,C,uniform,0.1,1,31,2,cold,read_ns,153.491 +csv,A,B,uniform,0.1,1,31,2,cold,read_ns,260.586 +csv,A,S,uniform,0.1,1,31,2,cold,read_ns,309.932 +csv,A,C,uniform,0.1,1,31,4,-,resolve_ns,29.174 +csv,A,C,uniform,0.1,1,31,4,hot,read_ns,28.282 +csv,A,B,uniform,0.1,1,31,4,hot,read_ns,23.837 +csv,A,S,uniform,0.1,1,31,4,hot,read_ns,139.201 +csv,A,C,uniform,0.1,1,31,4,cold,read_ns,194.312 +csv,A,B,uniform,0.1,1,31,4,cold,read_ns,241.015 +csv,A,S,uniform,0.1,1,31,4,cold,read_ns,411.037 +csv,A,C,uniform,0.1,1,31,8,-,resolve_ns,34.484 +csv,A,C,uniform,0.1,1,31,8,hot,read_ns,50.487 +csv,A,B,uniform,0.1,1,31,8,hot,read_ns,40.091 +csv,A,S,uniform,0.1,1,31,8,hot,read_ns,305.500 +csv,A,C,uniform,0.1,1,31,8,cold,read_ns,309.159 +csv,A,B,uniform,0.1,1,31,8,cold,read_ns,393.240 +csv,A,S,uniform,0.1,1,31,8,cold,read_ns,716.293 +csv,A,C,uniform,0.1,1,31,16,-,resolve_ns,44.474 +csv,A,C,uniform,0.1,1,31,16,hot,read_ns,100.927 +csv,A,B,uniform,0.1,1,31,16,hot,read_ns,71.781 +csv,A,S,uniform,0.1,1,31,16,hot,read_ns,651.454 +csv,A,C,uniform,0.1,1,31,16,cold,read_ns,544.334 +csv,A,B,uniform,0.1,1,31,16,cold,read_ns,558.531 +csv,A,S,uniform,0.1,1,31,16,cold,read_ns,1560.285 +csv,A,C,uniform,0.1,1,31,31,-,resolve_ns,61.761 +csv,A,C,uniform,0.1,1,31,31,hot,read_ns,206.087 +csv,A,B,uniform,0.1,1,31,31,hot,read_ns,138.292 +csv,A,S,uniform,0.1,1,31,31,hot,read_ns,1530.791 +csv,A,C,uniform,0.1,1,31,31,cold,read_ns,911.185 +csv,A,B,uniform,0.1,1,31,31,cold,read_ns,886.639 +csv,A,S,uniform,0.1,1,31,31,cold,read_ns,2859.724 +csv,B,C,uniform,0.1,1,31,2,hot,shared_ns_per_word,0.908 +csv,B,C,uniform,0.1,1,31,2,hot,hamming_ns_per_word,0.928 +csv,B,C,uniform,0.1,1,31,2,-,shared_count,671.000 +csv,C,C,uniform,0.1,1,31,31,hot,row_ns,205.887 +csv,A,C,uniform,0.5,1,1,1,-,resolve_ns,26.025 +csv,A,C,uniform,0.5,1,1,1,hot,read_ns,10.288 +csv,A,B,uniform,0.5,1,1,1,hot,read_ns,10.371 +csv,A,S,uniform,0.5,1,1,1,hot,read_ns,56.172 +csv,A,C,uniform,0.5,1,1,1,cold,read_ns,96.458 +csv,A,B,uniform,0.5,1,1,1,cold,read_ns,154.139 +csv,A,S,uniform,0.5,1,1,1,cold,read_ns,233.239 +csv,A,C,uniform,0.5,1,2,2,-,resolve_ns,27.918 +csv,A,C,uniform,0.5,1,2,2,hot,read_ns,19.581 +csv,A,B,uniform,0.5,1,2,2,hot,read_ns,16.025 +csv,A,S,uniform,0.5,1,2,2,hot,read_ns,108.118 +csv,A,C,uniform,0.5,1,2,2,cold,read_ns,147.692 +csv,A,B,uniform,0.5,1,2,2,cold,read_ns,190.762 +csv,A,S,uniform,0.5,1,2,2,cold,read_ns,400.565 +csv,B,C,uniform,0.5,1,2,2,hot,shared_ns_per_word,0.922 +csv,B,C,uniform,0.5,1,2,2,hot,hamming_ns_per_word,0.966 +csv,B,C,uniform,0.5,1,2,2,-,shared_count,16394.000 +csv,A,C,uniform,0.5,1,4,4,-,resolve_ns,31.374 +csv,A,C,uniform,0.5,1,4,4,hot,read_ns,21.604 +csv,A,B,uniform,0.5,1,4,4,hot,read_ns,26.708 +csv,A,S,uniform,0.5,1,4,4,hot,read_ns,239.702 +csv,A,C,uniform,0.5,1,4,4,cold,read_ns,213.022 +csv,A,B,uniform,0.5,1,4,4,cold,read_ns,248.983 +csv,A,S,uniform,0.5,1,4,4,cold,read_ns,759.273 +csv,B,C,uniform,0.5,1,4,2,hot,shared_ns_per_word,0.952 +csv,B,C,uniform,0.5,1,4,2,hot,hamming_ns_per_word,0.947 +csv,B,C,uniform,0.5,1,4,2,-,shared_count,16394.000 +csv,A,C,uniform,0.5,1,8,1,-,resolve_ns,26.782 +csv,A,C,uniform,0.5,1,8,1,hot,read_ns,10.611 +csv,A,B,uniform,0.5,1,8,1,hot,read_ns,13.143 +csv,A,S,uniform,0.5,1,8,1,hot,read_ns,53.653 +csv,A,C,uniform,0.5,1,8,1,cold,read_ns,96.068 +csv,A,B,uniform,0.5,1,8,1,cold,read_ns,193.324 +csv,A,S,uniform,0.5,1,8,1,cold,read_ns,225.891 +csv,A,C,uniform,0.5,1,8,2,-,resolve_ns,28.163 +csv,A,C,uniform,0.5,1,8,2,hot,read_ns,18.753 +csv,A,B,uniform,0.5,1,8,2,hot,read_ns,19.698 +csv,A,S,uniform,0.5,1,8,2,hot,read_ns,108.745 +csv,A,C,uniform,0.5,1,8,2,cold,read_ns,144.377 +csv,A,B,uniform,0.5,1,8,2,cold,read_ns,214.206 +csv,A,S,uniform,0.5,1,8,2,cold,read_ns,396.160 +csv,A,C,uniform,0.5,1,8,4,-,resolve_ns,29.157 +csv,A,C,uniform,0.5,1,8,4,hot,read_ns,21.052 +csv,A,B,uniform,0.5,1,8,4,hot,read_ns,29.093 +csv,A,S,uniform,0.5,1,8,4,hot,read_ns,229.152 +csv,A,C,uniform,0.5,1,8,4,cold,read_ns,204.026 +csv,A,B,uniform,0.5,1,8,4,cold,read_ns,281.790 +csv,A,S,uniform,0.5,1,8,4,cold,read_ns,711.609 +csv,A,C,uniform,0.5,1,8,8,-,resolve_ns,35.083 +csv,A,C,uniform,0.5,1,8,8,hot,read_ns,43.340 +csv,A,B,uniform,0.5,1,8,8,hot,read_ns,48.344 +csv,A,S,uniform,0.5,1,8,8,hot,read_ns,499.998 +csv,A,C,uniform,0.5,1,8,8,cold,read_ns,329.146 +csv,A,B,uniform,0.5,1,8,8,cold,read_ns,434.442 +csv,A,S,uniform,0.5,1,8,8,cold,read_ns,1469.497 +csv,B,C,uniform,0.5,1,8,2,hot,shared_ns_per_word,1.017 +csv,B,C,uniform,0.5,1,8,2,hot,hamming_ns_per_word,1.119 +csv,B,C,uniform,0.5,1,8,2,-,shared_count,16394.000 +csv,A,C,uniform,0.5,1,16,16,-,resolve_ns,44.561 +csv,A,C,uniform,0.5,1,16,16,hot,read_ns,122.398 +csv,A,B,uniform,0.5,1,16,16,hot,read_ns,109.837 +csv,A,S,uniform,0.5,1,16,16,hot,read_ns,1971.669 +csv,A,C,uniform,0.5,1,16,16,cold,read_ns,767.208 +csv,A,B,uniform,0.5,1,16,16,cold,read_ns,659.390 +csv,A,S,uniform,0.5,1,16,16,cold,read_ns,3592.153 +csv,B,C,uniform,0.5,1,16,2,hot,shared_ns_per_word,0.917 +csv,B,C,uniform,0.5,1,16,2,hot,hamming_ns_per_word,0.916 +csv,B,C,uniform,0.5,1,16,2,-,shared_count,16394.000 +csv,A,C,uniform,0.5,1,31,1,-,resolve_ns,26.078 +csv,A,C,uniform,0.5,1,31,1,hot,read_ns,10.288 +csv,A,B,uniform,0.5,1,31,1,hot,read_ns,13.393 +csv,A,S,uniform,0.5,1,31,1,hot,read_ns,53.711 +csv,A,C,uniform,0.5,1,31,1,cold,read_ns,103.071 +csv,A,B,uniform,0.5,1,31,1,cold,read_ns,201.549 +csv,A,S,uniform,0.5,1,31,1,cold,read_ns,233.037 +csv,A,C,uniform,0.5,1,31,2,-,resolve_ns,28.272 +csv,A,C,uniform,0.5,1,31,2,hot,read_ns,19.123 +csv,A,B,uniform,0.5,1,31,2,hot,read_ns,18.149 +csv,A,S,uniform,0.5,1,31,2,hot,read_ns,106.956 +csv,A,C,uniform,0.5,1,31,2,cold,read_ns,171.213 +csv,A,B,uniform,0.5,1,31,2,cold,read_ns,393.450 +csv,A,S,uniform,0.5,1,31,2,cold,read_ns,508.550 +csv,A,C,uniform,0.5,1,31,4,-,resolve_ns,46.936 +csv,A,C,uniform,0.5,1,31,4,hot,read_ns,32.385 +csv,A,B,uniform,0.5,1,31,4,hot,read_ns,43.210 +csv,A,S,uniform,0.5,1,31,4,hot,read_ns,245.482 +csv,A,C,uniform,0.5,1,31,4,cold,read_ns,304.569 +csv,A,B,uniform,0.5,1,31,4,cold,read_ns,304.710 +csv,A,S,uniform,0.5,1,31,4,cold,read_ns,736.025 +csv,A,C,uniform,0.5,1,31,8,-,resolve_ns,34.624 +csv,A,C,uniform,0.5,1,31,8,hot,read_ns,41.971 +csv,A,B,uniform,0.5,1,31,8,hot,read_ns,49.265 +csv,A,S,uniform,0.5,1,31,8,hot,read_ns,513.113 +csv,A,C,uniform,0.5,1,31,8,cold,read_ns,390.670 +csv,A,B,uniform,0.5,1,31,8,cold,read_ns,502.394 +csv,A,S,uniform,0.5,1,31,8,cold,read_ns,1544.188 +csv,A,C,uniform,0.5,1,31,16,-,resolve_ns,44.539 +csv,A,C,uniform,0.5,1,31,16,hot,read_ns,119.256 +csv,A,B,uniform,0.5,1,31,16,hot,read_ns,121.672 +csv,A,S,uniform,0.5,1,31,16,hot,read_ns,1690.148 +csv,A,C,uniform,0.5,1,31,16,cold,read_ns,580.150 +csv,A,B,uniform,0.5,1,31,16,cold,read_ns,715.242 +csv,A,S,uniform,0.5,1,31,16,cold,read_ns,5063.861 +csv,A,C,uniform,0.5,1,31,31,-,resolve_ns,61.762 +csv,A,C,uniform,0.5,1,31,31,hot,read_ns,339.186 +csv,A,B,uniform,0.5,1,31,31,hot,read_ns,222.771 +csv,A,S,uniform,0.5,1,31,31,hot,read_ns,5219.523 +csv,A,C,uniform,0.5,1,31,31,cold,read_ns,1142.223 +csv,A,B,uniform,0.5,1,31,31,cold,read_ns,981.537 +csv,A,S,uniform,0.5,1,31,31,cold,read_ns,7835.720 +csv,B,C,uniform,0.5,1,31,2,hot,shared_ns_per_word,1.156 +csv,B,C,uniform,0.5,1,31,2,hot,hamming_ns_per_word,1.140 +csv,B,C,uniform,0.5,1,31,2,-,shared_count,16394.000 +csv,C,C,uniform,0.5,1,31,31,hot,row_ns,613.008 +csv,A,C,uniform,1,1,1,1,-,resolve_ns,38.709 +csv,A,C,uniform,1,1,1,1,hot,read_ns,11.966 +csv,A,B,uniform,1,1,1,1,hot,read_ns,20.680 +csv,A,S,uniform,1,1,1,1,hot,read_ns,82.441 +csv,A,C,uniform,1,1,1,1,cold,read_ns,51.891 +csv,A,B,uniform,1,1,1,1,cold,read_ns,130.585 +csv,A,S,uniform,1,1,1,1,cold,read_ns,172.050 +csv,A,C,uniform,1,1,2,2,-,resolve_ns,28.398 +csv,A,C,uniform,1,1,2,2,hot,read_ns,10.757 +csv,A,B,uniform,1,1,2,2,hot,read_ns,17.750 +csv,A,S,uniform,1,1,2,2,hot,read_ns,103.088 +csv,A,C,uniform,1,1,2,2,cold,read_ns,66.321 +csv,A,B,uniform,1,1,2,2,cold,read_ns,165.495 +csv,A,S,uniform,1,1,2,2,cold,read_ns,341.894 +csv,B,C,uniform,1,1,2,2,hot,shared_ns_per_word,0.929 +csv,B,C,uniform,1,1,2,2,hot,hamming_ns_per_word,0.925 +csv,B,C,uniform,1,1,2,2,-,shared_count,65536.000 +csv,A,C,uniform,1,1,4,4,-,resolve_ns,29.525 +csv,A,C,uniform,1,1,4,4,hot,read_ns,15.085 +csv,A,B,uniform,1,1,4,4,hot,read_ns,27.707 +csv,A,S,uniform,1,1,4,4,hot,read_ns,229.768 +csv,A,C,uniform,1,1,4,4,cold,read_ns,114.643 +csv,A,B,uniform,1,1,4,4,cold,read_ns,207.836 +csv,A,S,uniform,1,1,4,4,cold,read_ns,838.746 +csv,B,C,uniform,1,1,4,2,hot,shared_ns_per_word,0.940 +csv,B,C,uniform,1,1,4,2,hot,hamming_ns_per_word,0.916 +csv,B,C,uniform,1,1,4,2,-,shared_count,65536.000 +csv,A,C,uniform,1,1,8,1,-,resolve_ns,26.755 +csv,A,C,uniform,1,1,8,1,hot,read_ns,7.359 +csv,A,B,uniform,1,1,8,1,hot,read_ns,12.825 +csv,A,S,uniform,1,1,8,1,hot,read_ns,51.667 +csv,A,C,uniform,1,1,8,1,cold,read_ns,53.774 +csv,A,B,uniform,1,1,8,1,cold,read_ns,163.624 +csv,A,S,uniform,1,1,8,1,cold,read_ns,161.703 +csv,A,C,uniform,1,1,8,2,-,resolve_ns,27.411 +csv,A,C,uniform,1,1,8,2,hot,read_ns,10.277 +csv,A,B,uniform,1,1,8,2,hot,read_ns,17.693 +csv,A,S,uniform,1,1,8,2,hot,read_ns,103.415 +csv,A,C,uniform,1,1,8,2,cold,read_ns,72.181 +csv,A,B,uniform,1,1,8,2,cold,read_ns,221.351 +csv,A,S,uniform,1,1,8,2,cold,read_ns,547.314 +csv,A,C,uniform,1,1,8,4,-,resolve_ns,29.358 +csv,A,C,uniform,1,1,8,4,hot,read_ns,15.616 +csv,A,B,uniform,1,1,8,4,hot,read_ns,27.702 +csv,A,S,uniform,1,1,8,4,hot,read_ns,225.716 +csv,A,C,uniform,1,1,8,4,cold,read_ns,120.822 +csv,A,B,uniform,1,1,8,4,cold,read_ns,257.745 +csv,A,S,uniform,1,1,8,4,cold,read_ns,866.461 +csv,A,C,uniform,1,1,8,8,-,resolve_ns,70.795 +csv,A,C,uniform,1,1,8,8,hot,read_ns,36.396 +csv,A,B,uniform,1,1,8,8,hot,read_ns,45.225 +csv,A,S,uniform,1,1,8,8,hot,read_ns,696.314 +csv,A,C,uniform,1,1,8,8,cold,read_ns,244.067 +csv,A,B,uniform,1,1,8,8,cold,read_ns,430.865 +csv,A,S,uniform,1,1,8,8,cold,read_ns,1782.851 +csv,B,C,uniform,1,1,8,2,hot,shared_ns_per_word,0.926 +csv,B,C,uniform,1,1,8,2,hot,hamming_ns_per_word,0.969 +csv,B,C,uniform,1,1,8,2,-,shared_count,65536.000 +csv,A,C,uniform,1,1,16,16,-,resolve_ns,66.390 +csv,A,C,uniform,1,1,16,16,hot,read_ns,130.734 +csv,A,B,uniform,1,1,16,16,hot,read_ns,70.160 +csv,A,S,uniform,1,1,16,16,hot,read_ns,2123.771 +csv,A,C,uniform,1,1,16,16,cold,read_ns,567.089 +csv,A,B,uniform,1,1,16,16,cold,read_ns,458.311 +csv,A,S,uniform,1,1,16,16,cold,read_ns,4585.251 +csv,B,C,uniform,1,1,16,2,hot,shared_ns_per_word,0.981 +csv,B,C,uniform,1,1,16,2,hot,hamming_ns_per_word,0.937 +csv,B,C,uniform,1,1,16,2,-,shared_count,65536.000 +csv,A,C,uniform,1,1,31,1,-,resolve_ns,49.450 +csv,A,C,uniform,1,1,31,1,hot,read_ns,14.942 +csv,A,B,uniform,1,1,31,1,hot,read_ns,21.155 +csv,A,S,uniform,1,1,31,1,hot,read_ns,86.310 +csv,A,C,uniform,1,1,31,1,cold,read_ns,53.887 +csv,A,B,uniform,1,1,31,1,cold,read_ns,199.623 +csv,A,S,uniform,1,1,31,1,cold,read_ns,189.378 +csv,A,C,uniform,1,1,31,2,-,resolve_ns,28.416 +csv,A,C,uniform,1,1,31,2,hot,read_ns,9.723 +csv,A,B,uniform,1,1,31,2,hot,read_ns,17.851 +csv,A,S,uniform,1,1,31,2,hot,read_ns,109.730 +csv,A,C,uniform,1,1,31,2,cold,read_ns,72.803 +csv,A,B,uniform,1,1,31,2,cold,read_ns,286.540 +csv,A,S,uniform,1,1,31,2,cold,read_ns,374.164 +csv,A,C,uniform,1,1,31,4,-,resolve_ns,32.340 +csv,A,C,uniform,1,1,31,4,hot,read_ns,15.019 +csv,A,B,uniform,1,1,31,4,hot,read_ns,27.722 +csv,A,S,uniform,1,1,31,4,hot,read_ns,235.954 +csv,A,C,uniform,1,1,31,4,cold,read_ns,131.098 +csv,A,B,uniform,1,1,31,4,cold,read_ns,272.592 +csv,A,S,uniform,1,1,31,4,cold,read_ns,715.236 +csv,A,C,uniform,1,1,31,8,-,resolve_ns,33.850 +csv,A,C,uniform,1,1,31,8,hot,read_ns,31.844 +csv,A,B,uniform,1,1,31,8,hot,read_ns,43.031 +csv,A,S,uniform,1,1,31,8,hot,read_ns,594.736 +csv,A,C,uniform,1,1,31,8,cold,read_ns,223.981 +csv,A,B,uniform,1,1,31,8,cold,read_ns,434.619 +csv,A,S,uniform,1,1,31,8,cold,read_ns,2090.685 +csv,A,C,uniform,1,1,31,16,-,resolve_ns,78.088 +csv,A,C,uniform,1,1,31,16,hot,read_ns,210.854 +csv,A,B,uniform,1,1,31,16,hot,read_ns,120.353 +csv,A,S,uniform,1,1,31,16,hot,read_ns,2016.744 +csv,A,C,uniform,1,1,31,16,cold,read_ns,519.448 +csv,A,B,uniform,1,1,31,16,cold,read_ns,644.111 +csv,A,S,uniform,1,1,31,16,cold,read_ns,5219.416 +csv,A,C,uniform,1,1,31,31,-,resolve_ns,62.260 +csv,A,C,uniform,1,1,31,31,hot,read_ns,474.526 +csv,A,B,uniform,1,1,31,31,hot,read_ns,118.892 +csv,A,S,uniform,1,1,31,31,hot,read_ns,5517.636 +csv,A,C,uniform,1,1,31,31,cold,read_ns,1263.842 +csv,A,B,uniform,1,1,31,31,cold,read_ns,787.650 +csv,A,S,uniform,1,1,31,31,cold,read_ns,12994.097 +csv,B,C,uniform,1,1,31,2,hot,shared_ns_per_word,0.991 +csv,B,C,uniform,1,1,31,2,hot,hamming_ns_per_word,0.973 +csv,B,C,uniform,1,1,31,2,-,shared_count,65536.000 +csv,C,C,uniform,1,1,31,31,hot,row_ns,614.285 +csv,A,C,uniform,0.01,1,31,2,hot,read_ns,40.161 +csv,A,C,uniform,0.01,1,31,2,cold,read_ns,169.544 +csv,B,C,uniform,0.01,1,31,1,hot,session_or_ns_per_word,0.872 +csv,A,C,uniform,0.01,8,31,2,hot,read_ns,40.052 +csv,A,C,uniform,0.01,8,31,2,cold,read_ns,160.006 +csv,B,C,uniform,0.01,8,31,1,hot,session_or_ns_per_word,5.125 +csv,A,C,uniform,0.01,64,31,2,hot,read_ns,54.648 +csv,A,C,uniform,0.01,64,31,2,cold,read_ns,191.951 +csv,B,C,uniform,0.01,64,31,1,hot,session_or_ns_per_word,19.006 +csv,A,C,uniform,0.1,1,31,2,hot,read_ns,36.926 +csv,A,C,uniform,0.1,1,31,2,cold,read_ns,152.501 +csv,B,C,uniform,0.1,1,31,1,hot,session_or_ns_per_word,0.853 +csv,A,C,uniform,0.1,8,31,2,hot,read_ns,45.326 +csv,A,C,uniform,0.1,8,31,2,cold,read_ns,169.047 +csv,B,C,uniform,0.1,8,31,1,hot,session_or_ns_per_word,4.240 +csv,A,C,uniform,0.1,64,31,2,hot,read_ns,67.185 +csv,A,C,uniform,0.1,64,31,2,cold,read_ns,364.876 +csv,B,C,uniform,0.1,64,31,1,hot,session_or_ns_per_word,31.937 +csv,A,C,uniform,0.01,1,31,2,hot,read_ns,13.573 +csv,A,B,uniform,0.01,1,31,2,hot,read_ns,12.158 +csv,A,C,uniform,0.01,1,31,2,cold,read_ns,127.552 +csv,A,B,uniform,0.01,1,31,2,cold,read_ns,141.906 +csv,B,C,uniform,0.01,1,31,2,-,shared_count,7.000 +csv,B,C,uniform,0.01,1,31,2,-,hamming,1263.000 +csv,B,C,uniform,0.01,1,31,2,-,pop_a,653.000 +csv,A,C,clustered,0.01,1,31,2,hot,read_ns,13.573 +csv,A,B,clustered,0.01,1,31,2,hot,read_ns,12.335 +csv,A,C,clustered,0.01,1,31,2,cold,read_ns,120.742 +csv,A,B,clustered,0.01,1,31,2,cold,read_ns,143.959 +csv,B,C,clustered,0.01,1,31,2,-,shared_count,0.000 +csv,B,C,clustered,0.01,1,31,2,-,hamming,704.000 +csv,B,C,clustered,0.01,1,31,2,-,pop_a,384.000 +csv,A,C,contiguous,0.01,1,31,2,hot,read_ns,13.625 +csv,A,B,contiguous,0.01,1,31,2,hot,read_ns,13.119 +csv,A,C,contiguous,0.01,1,31,2,cold,read_ns,123.758 +csv,A,B,contiguous,0.01,1,31,2,cold,read_ns,146.208 +csv,B,C,contiguous,0.01,1,31,2,-,shared_count,0.000 +csv,B,C,contiguous,0.01,1,31,2,-,hamming,1310.000 +csv,B,C,contiguous,0.01,1,31,2,-,pop_a,655.000 +csv,A,C,morton,0.01,1,31,2,hot,read_ns,14.115 +csv,A,B,morton,0.01,1,31,2,hot,read_ns,12.966 +csv,A,C,morton,0.01,1,31,2,cold,read_ns,125.544 +csv,A,B,morton,0.01,1,31,2,cold,read_ns,155.312 +csv,B,C,morton,0.01,1,31,2,-,shared_count,68.000 +csv,B,C,morton,0.01,1,31,2,-,hamming,1401.000 +csv,B,C,morton,0.01,1,31,2,-,pop_a,778.000 +csv,A,C,disjoint,0.01,1,31,2,hot,read_ns,18.428 +csv,A,B,disjoint,0.01,1,31,2,hot,read_ns,18.220 +csv,A,C,disjoint,0.01,1,31,2,cold,read_ns,189.296 +csv,A,B,disjoint,0.01,1,31,2,cold,read_ns,136.294 +csv,B,C,disjoint,0.01,1,31,2,-,shared_count,0.000 +csv,B,C,disjoint,0.01,1,31,2,-,hamming,41.000 +csv,B,C,disjoint,0.01,1,31,2,-,pop_a,22.000 +csv,A,C,overlapping,0.01,1,31,2,hot,read_ns,13.542 +csv,A,B,overlapping,0.01,1,31,2,hot,read_ns,10.894 +csv,A,C,overlapping,0.01,1,31,2,cold,read_ns,130.693 +csv,A,B,overlapping,0.01,1,31,2,cold,read_ns,134.765 +csv,B,C,overlapping,0.01,1,31,2,-,shared_count,653.000 +csv,B,C,overlapping,0.01,1,31,2,-,hamming,54.000 +csv,B,C,overlapping,0.01,1,31,2,-,pop_a,653.000 +csv,A,C,uniform,0.1,1,31,2,hot,read_ns,13.094 +csv,A,B,uniform,0.1,1,31,2,hot,read_ns,19.449 +csv,A,C,uniform,0.1,1,31,2,cold,read_ns,127.514 +csv,A,B,uniform,0.1,1,31,2,cold,read_ns,200.340 +csv,B,C,uniform,0.1,1,31,2,-,shared_count,671.000 +csv,B,C,uniform,0.1,1,31,2,-,hamming,11735.000 +csv,B,C,uniform,0.1,1,31,2,-,pop_a,6592.000 +csv,A,C,clustered,0.1,1,31,2,hot,read_ns,13.251 +csv,A,B,clustered,0.1,1,31,2,hot,read_ns,17.916 +csv,A,C,clustered,0.1,1,31,2,cold,read_ns,121.785 +csv,A,B,clustered,0.1,1,31,2,cold,read_ns,194.101 +csv,B,C,clustered,0.1,1,31,2,-,shared_count,896.000 +csv,B,C,clustered,0.1,1,31,2,-,hamming,11584.000 +csv,B,C,clustered,0.1,1,31,2,-,pop_a,7232.000 +csv,A,C,contiguous,0.1,1,31,2,hot,read_ns,12.894 +csv,A,B,contiguous,0.1,1,31,2,hot,read_ns,18.169 +csv,A,C,contiguous,0.1,1,31,2,cold,read_ns,190.888 +csv,A,B,contiguous,0.1,1,31,2,cold,read_ns,180.409 +csv,B,C,contiguous,0.1,1,31,2,-,shared_count,0.000 +csv,B,C,contiguous,0.1,1,31,2,-,hamming,13108.000 +csv,B,C,contiguous,0.1,1,31,2,-,pop_a,6554.000 +csv,A,C,morton,0.1,1,31,2,hot,read_ns,13.488 +csv,A,B,morton,0.1,1,31,2,hot,read_ns,17.080 +csv,A,C,morton,0.1,1,31,2,cold,read_ns,121.065 +csv,A,B,morton,0.1,1,31,2,cold,read_ns,195.180 +csv,B,C,morton,0.1,1,31,2,-,shared_count,633.000 +csv,B,C,morton,0.1,1,31,2,-,hamming,11974.000 +csv,B,C,morton,0.1,1,31,2,-,pop_a,6668.000 +csv,A,C,disjoint,0.1,1,31,2,hot,read_ns,13.774 +csv,A,B,disjoint,0.1,1,31,2,hot,read_ns,11.949 +csv,A,C,disjoint,0.1,1,31,2,cold,read_ns,122.487 +csv,A,B,disjoint,0.1,1,31,2,cold,read_ns,211.935 +csv,B,C,disjoint,0.1,1,31,2,-,shared_count,0.000 +csv,B,C,disjoint,0.1,1,31,2,-,hamming,411.000 +csv,B,C,disjoint,0.1,1,31,2,-,pop_a,202.000 +csv,A,C,overlapping,0.1,1,31,2,hot,read_ns,18.646 +csv,A,B,overlapping,0.1,1,31,2,hot,read_ns,19.460 +csv,A,C,overlapping,0.1,1,31,2,cold,read_ns,136.975 +csv,A,B,overlapping,0.1,1,31,2,cold,read_ns,250.737 +csv,B,C,overlapping,0.1,1,31,2,-,shared_count,6519.000 +csv,B,C,overlapping,0.1,1,31,2,-,hamming,614.000 +csv,B,C,overlapping,0.1,1,31,2,-,pop_a,6592.000 +csv,M,-,uniform,0.001,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,uniform,0.001,1,31,0,-,payload_bytes,33296.000 +csv,M,-,uniform,0.001,1,31,0,-,presence_bytes,253952.000 +csv,M,-,uniform,0.001,1,31,0,-,sparse_persist_bytes,41620.000 +csv,M,C-lazy,uniform,0.001,1,31,0,-,virtual_delta_bytes,32907264.000 +csv,M,C-lazy,uniform,0.001,1,31,0,-,rss_delta_bytes,7958528.000 +csv,M,C-lazy,uniform,0.001,1,31,0,-,minor_faults,1933.000 +csv,M,C-lazy,uniform,0.001,1,31,0,-,seal_ns_per_dirty,2628.402 +csv,M,C-eager,uniform,0.001,1,31,0,-,virtual_delta_bytes,32907264.000 +csv,M,C-eager,uniform,0.001,1,31,0,-,rss_delta_bytes,32808960.000 +csv,M,C-eager,uniform,0.001,1,31,0,-,minor_faults,8000.000 +csv,M,C-eager,uniform,0.001,1,31,0,-,seal_ns_per_dirty,10486.933 +csv,M,S,uniform,0.001,1,31,0,-,virtual_delta_bytes,0.000 +csv,M,S,uniform,0.001,1,31,0,-,rss_delta_bytes,90112.000 +csv,M,S,uniform,0.001,1,31,0,-,minor_faults,12.000 +csv,M,S,uniform,0.001,1,31,0,-,seal_ns_per_dirty,19.266 +csv,M,-,uniform,0.001,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,uniform,0.001,8,31,0,-,payload_bytes,259392.000 +csv,M,-,uniform,0.001,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,uniform,0.001,8,31,0,-,sparse_persist_bytes,324240.000 +csv,M,C-lazy,uniform,0.001,8,31,0,-,virtual_delta_bytes,263139328.000 +csv,M,C-lazy,uniform,0.001,8,31,0,-,rss_delta_bytes,61739008.000 +csv,M,C-lazy,uniform,0.001,8,31,0,-,minor_faults,15063.000 +csv,M,C-lazy,uniform,0.001,8,31,0,-,seal_ns_per_dirty,2641.220 +csv,M,C-eager,uniform,0.001,8,31,0,-,virtual_delta_bytes,263139328.000 +csv,M,C-eager,uniform,0.001,8,31,0,-,rss_delta_bytes,262144000.000 +csv,M,C-eager,uniform,0.001,8,31,0,-,minor_faults,63990.000 +csv,M,C-eager,uniform,0.001,8,31,0,-,seal_ns_per_dirty,11467.883 +csv,M,S,uniform,0.001,8,31,0,-,virtual_delta_bytes,405504.000 +csv,M,S,uniform,0.001,8,31,0,-,rss_delta_bytes,393216.000 +csv,M,S,uniform,0.001,8,31,0,-,minor_faults,86.000 +csv,M,S,uniform,0.001,8,31,0,-,seal_ns_per_dirty,21.309 +csv,M,-,uniform,0.001,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,uniform,0.001,64,31,0,-,payload_bytes,2082960.000 +csv,M,-,uniform,0.001,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,uniform,0.001,64,31,0,-,sparse_persist_bytes,2603700.000 +csv,M,C-lazy,uniform,0.001,64,31,0,-,virtual_delta_bytes,2104942592.000 +csv,M,C-lazy,uniform,0.001,64,31,0,-,rss_delta_bytes,492896256.000 +csv,M,C-lazy,uniform,0.001,64,31,0,-,minor_faults,120326.000 +csv,M,C-lazy,uniform,0.001,64,31,0,-,seal_ns_per_dirty,2670.783 +csv,M,C-eager,uniform,0.001,64,31,0,-,virtual_delta_bytes,2104942592.000 +csv,M,C-eager,uniform,0.001,64,31,0,-,rss_delta_bytes,2096828416.000 +csv,M,C-eager,uniform,0.001,64,31,0,-,minor_faults,511911.000 +csv,M,C-eager,uniform,0.001,64,31,0,-,seal_ns_per_dirty,10290.290 +csv,M,S,uniform,0.001,64,31,0,-,virtual_delta_bytes,2703360.000 +csv,M,S,uniform,0.001,64,31,0,-,rss_delta_bytes,2809856.000 +csv,M,S,uniform,0.001,64,31,0,-,minor_faults,676.000 +csv,M,S,uniform,0.001,64,31,0,-,seal_ns_per_dirty,21.392 +csv,M,-,uniform,0.01,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,uniform,0.01,1,31,0,-,payload_bytes,325840.000 +csv,M,-,uniform,0.01,1,31,0,-,presence_bytes,253952.000 +csv,M,-,uniform,0.01,1,31,0,-,sparse_persist_bytes,407300.000 +csv,M,C-lazy,uniform,0.01,1,31,0,-,virtual_delta_bytes,32911360.000 +csv,M,C-lazy,uniform,0.01,1,31,0,-,rss_delta_bytes,30375936.000 +csv,M,C-lazy,uniform,0.01,1,31,0,-,minor_faults,7406.000 +csv,M,C-lazy,uniform,0.01,1,31,0,-,seal_ns_per_dirty,978.777 +csv,M,C-eager,uniform,0.01,1,31,0,-,virtual_delta_bytes,32911360.000 +csv,M,C-eager,uniform,0.01,1,31,0,-,rss_delta_bytes,32813056.000 +csv,M,C-eager,uniform,0.01,1,31,0,-,minor_faults,8001.000 +csv,M,C-eager,uniform,0.01,1,31,0,-,seal_ns_per_dirty,1017.842 +csv,M,S,uniform,0.01,1,31,0,-,virtual_delta_bytes,421888.000 +csv,M,S,uniform,0.01,1,31,0,-,rss_delta_bytes,462848.000 +csv,M,S,uniform,0.01,1,31,0,-,minor_faults,103.000 +csv,M,S,uniform,0.01,1,31,0,-,seal_ns_per_dirty,18.384 +csv,M,-,uniform,0.01,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,uniform,0.01,8,31,0,-,payload_bytes,2598816.000 +csv,M,-,uniform,0.01,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,uniform,0.01,8,31,0,-,sparse_persist_bytes,3248520.000 +csv,M,C-lazy,uniform,0.01,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-lazy,uniform,0.01,8,31,0,-,rss_delta_bytes,242229248.000 +csv,M,C-lazy,uniform,0.01,8,31,0,-,minor_faults,59128.000 +csv,M,C-lazy,uniform,0.01,8,31,0,-,seal_ns_per_dirty,866.390 +csv,M,C-eager,uniform,0.01,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-eager,uniform,0.01,8,31,0,-,rss_delta_bytes,262148096.000 +csv,M,C-eager,uniform,0.01,8,31,0,-,minor_faults,63991.000 +csv,M,C-eager,uniform,0.01,8,31,0,-,seal_ns_per_dirty,1212.982 +csv,M,S,uniform,0.01,8,31,0,-,virtual_delta_bytes,3301376.000 +csv,M,S,uniform,0.01,8,31,0,-,rss_delta_bytes,3317760.000 +csv,M,S,uniform,0.01,8,31,0,-,minor_faults,800.000 +csv,M,S,uniform,0.01,8,31,0,-,seal_ns_per_dirty,25.640 +csv,M,-,uniform,0.01,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,uniform,0.01,64,31,0,-,payload_bytes,20821312.000 +csv,M,-,uniform,0.01,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,uniform,0.01,64,31,0,-,sparse_persist_bytes,26026640.000 +csv,M,C-lazy,uniform,0.01,64,31,0,-,virtual_delta_bytes,2104799232.000 +csv,M,C-lazy,uniform,0.01,64,31,0,-,rss_delta_bytes,1939312640.000 +csv,M,C-lazy,uniform,0.01,64,31,0,-,minor_faults,473455.000 +csv,M,C-lazy,uniform,0.01,64,31,0,-,seal_ns_per_dirty,986.338 +csv,M,C-eager,uniform,0.01,64,31,0,-,virtual_delta_bytes,2104799232.000 +csv,M,C-eager,uniform,0.01,64,31,0,-,rss_delta_bytes,2096873472.000 +csv,M,C-eager,uniform,0.01,64,31,0,-,minor_faults,511922.000 +csv,M,C-eager,uniform,0.01,64,31,0,-,seal_ns_per_dirty,1067.388 +csv,M,S,uniform,0.01,64,31,0,-,virtual_delta_bytes,26124288.000 +csv,M,S,uniform,0.01,64,31,0,-,rss_delta_bytes,26234880.000 +csv,M,S,uniform,0.01,64,31,0,-,minor_faults,6395.000 +csv,M,S,uniform,0.01,64,31,0,-,seal_ns_per_dirty,19.041 +csv,M,-,uniform,0.1,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,uniform,0.1,1,31,0,-,payload_bytes,3256240.000 +csv,M,-,uniform,0.1,1,31,0,-,presence_bytes,253952.000 +csv,M,-,uniform,0.1,1,31,0,-,sparse_persist_bytes,4070300.000 +csv,M,C-lazy,uniform,0.1,1,31,0,-,virtual_delta_bytes,32911360.000 +csv,M,C-lazy,uniform,0.1,1,31,0,-,rss_delta_bytes,32829440.000 +csv,M,C-lazy,uniform,0.1,1,31,0,-,minor_faults,8005.000 +csv,M,C-lazy,uniform,0.1,1,31,0,-,seal_ns_per_dirty,110.067 +csv,M,C-eager,uniform,0.1,1,31,0,-,virtual_delta_bytes,32911360.000 +csv,M,C-eager,uniform,0.1,1,31,0,-,rss_delta_bytes,32829440.000 +csv,M,C-eager,uniform,0.1,1,31,0,-,minor_faults,8005.000 +csv,M,C-eager,uniform,0.1,1,31,0,-,seal_ns_per_dirty,111.067 +csv,M,S,uniform,0.1,1,31,0,-,virtual_delta_bytes,4128768.000 +csv,M,S,uniform,0.1,1,31,0,-,rss_delta_bytes,4124672.000 +csv,M,S,uniform,0.1,1,31,0,-,minor_faults,997.000 +csv,M,S,uniform,0.1,1,31,0,-,seal_ns_per_dirty,18.868 +csv,M,-,uniform,0.1,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,uniform,0.1,8,31,0,-,payload_bytes,26022352.000 +csv,M,-,uniform,0.1,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,uniform,0.1,8,31,0,-,sparse_persist_bytes,32527940.000 +csv,M,C-lazy,uniform,0.1,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-lazy,uniform,0.1,8,31,0,-,rss_delta_bytes,262262784.000 +csv,M,C-lazy,uniform,0.1,8,31,0,-,minor_faults,64019.000 +csv,M,C-lazy,uniform,0.1,8,31,0,-,seal_ns_per_dirty,119.842 +csv,M,C-eager,uniform,0.1,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-eager,uniform,0.1,8,31,0,-,rss_delta_bytes,262262784.000 +csv,M,C-eager,uniform,0.1,8,31,0,-,minor_faults,64019.000 +csv,M,C-eager,uniform,0.1,8,31,0,-,seal_ns_per_dirty,104.040 +csv,M,S,uniform,0.1,8,31,0,-,virtual_delta_bytes,32661504.000 +csv,M,S,uniform,0.1,8,31,0,-,rss_delta_bytes,32595968.000 +csv,M,S,uniform,0.1,8,31,0,-,minor_faults,7948.000 +csv,M,S,uniform,0.1,8,31,0,-,seal_ns_per_dirty,19.882 +csv,M,-,uniform,0.1,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,uniform,0.1,64,31,0,-,payload_bytes,208066064.000 +csv,M,-,uniform,0.1,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,uniform,0.1,64,31,0,-,sparse_persist_bytes,260082580.000 +csv,M,C-lazy,uniform,0.1,64,31,0,-,virtual_delta_bytes,2104938496.000 +csv,M,C-lazy,uniform,0.1,64,31,0,-,rss_delta_bytes,2097676288.000 +csv,M,C-lazy,uniform,0.1,64,31,0,-,minor_faults,512118.000 +csv,M,C-lazy,uniform,0.1,64,31,0,-,seal_ns_per_dirty,120.960 +csv,M,C-eager,uniform,0.1,64,31,0,-,virtual_delta_bytes,2104938496.000 +csv,M,C-eager,uniform,0.1,64,31,0,-,rss_delta_bytes,2097676288.000 +csv,M,C-eager,uniform,0.1,64,31,0,-,minor_faults,512118.000 +csv,M,C-eager,uniform,0.1,64,31,0,-,seal_ns_per_dirty,116.591 +csv,M,S,uniform,0.1,64,31,0,-,virtual_delta_bytes,260333568.000 +csv,M,S,uniform,0.1,64,31,0,-,rss_delta_bytes,260292608.000 +csv,M,S,uniform,0.1,64,31,0,-,minor_faults,63538.000 +csv,M,S,uniform,0.1,64,31,0,-,seal_ns_per_dirty,18.363 +csv,M,-,uniform,1,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,uniform,1,1,31,0,-,payload_bytes,32505856.000 +csv,M,-,uniform,1,1,31,0,-,presence_bytes,253952.000 +csv,M,-,uniform,1,1,31,0,-,sparse_persist_bytes,40632320.000 +csv,M,C-lazy,uniform,1,1,31,0,-,virtual_delta_bytes,32768000.000 +csv,M,C-lazy,uniform,1,1,31,0,-,rss_delta_bytes,32874496.000 +csv,M,C-lazy,uniform,1,1,31,0,-,minor_faults,8016.000 +csv,M,C-lazy,uniform,1,1,31,0,-,seal_ns_per_dirty,19.807 +csv,M,C-eager,uniform,1,1,31,0,-,virtual_delta_bytes,32768000.000 +csv,M,C-eager,uniform,1,1,31,0,-,rss_delta_bytes,32874496.000 +csv,M,C-eager,uniform,1,1,31,0,-,minor_faults,8016.000 +csv,M,C-eager,uniform,1,1,31,0,-,seal_ns_per_dirty,18.648 +csv,M,S,uniform,1,1,31,0,-,virtual_delta_bytes,40886272.000 +csv,M,S,uniform,1,1,31,0,-,rss_delta_bytes,40935424.000 +csv,M,S,uniform,1,1,31,0,-,minor_faults,9984.000 +csv,M,S,uniform,1,1,31,0,-,seal_ns_per_dirty,21.588 +csv,M,-,uniform,1,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,uniform,1,8,31,0,-,payload_bytes,260046848.000 +csv,M,-,uniform,1,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,uniform,1,8,31,0,-,sparse_persist_bytes,325058560.000 +csv,M,C-lazy,uniform,1,8,31,0,-,virtual_delta_bytes,262991872.000 +csv,M,C-lazy,uniform,1,8,31,0,-,rss_delta_bytes,263094272.000 +csv,M,C-lazy,uniform,1,8,31,0,-,minor_faults,64222.000 +csv,M,C-lazy,uniform,1,8,31,0,-,seal_ns_per_dirty,16.150 +csv,M,C-eager,uniform,1,8,31,0,-,virtual_delta_bytes,262991872.000 +csv,M,C-eager,uniform,1,8,31,0,-,rss_delta_bytes,263094272.000 +csv,M,C-eager,uniform,1,8,31,0,-,minor_faults,64222.000 +csv,M,C-eager,uniform,1,8,31,0,-,seal_ns_per_dirty,16.270 +csv,M,S,uniform,1,8,31,0,-,virtual_delta_bytes,327090176.000 +csv,M,S,uniform,1,8,31,0,-,rss_delta_bytes,327139328.000 +csv,M,S,uniform,1,8,31,0,-,minor_faults,79858.000 +csv,M,S,uniform,1,8,31,0,-,seal_ns_per_dirty,17.953 +csv,M,-,uniform,1,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,uniform,1,64,31,0,-,payload_bytes,2080374784.000 +csv,M,-,uniform,1,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,uniform,1,64,31,0,-,sparse_persist_bytes,2600468480.000 +csv,M,C-lazy,uniform,1,64,31,0,-,virtual_delta_bytes,2104803328.000 +csv,M,C-lazy,uniform,1,64,31,0,-,rss_delta_bytes,2104807424.000 +csv,M,C-lazy,uniform,1,64,31,0,-,minor_faults,513859.000 +csv,M,C-lazy,uniform,1,64,31,0,-,seal_ns_per_dirty,15.764 +csv,M,C-eager,uniform,1,64,31,0,-,virtual_delta_bytes,2104803328.000 +csv,M,C-eager,uniform,1,64,31,0,-,rss_delta_bytes,2104807424.000 +csv,M,C-eager,uniform,1,64,31,0,-,minor_faults,513859.000 +csv,M,C-eager,uniform,1,64,31,0,-,seal_ns_per_dirty,16.327 +csv,M,S,uniform,1,64,31,0,-,virtual_delta_bytes,2616721408.000 +csv,M,S,uniform,1,64,31,0,-,rss_delta_bytes,2616770560.000 +csv,M,S,uniform,1,64,31,0,-,minor_faults,638850.000 +csv,M,S,uniform,1,64,31,0,-,seal_ns_per_dirty,18.458 +csv,M,-,clustered,0.001,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,clustered,0.001,1,31,0,-,payload_bytes,27648.000 +csv,M,-,clustered,0.001,1,31,0,-,presence_bytes,253952.000 +csv,M,-,clustered,0.001,1,31,0,-,sparse_persist_bytes,34560.000 +csv,M,C-lazy,clustered,0.001,1,31,0,-,virtual_delta_bytes,32768000.000 +csv,M,C-lazy,clustered,0.001,1,31,0,-,rss_delta_bytes,557056.000 +csv,M,C-lazy,clustered,0.001,1,31,0,-,minor_faults,126.000 +csv,M,C-lazy,clustered,0.001,1,31,0,-,seal_ns_per_dirty,245.275 +csv,M,C-eager,clustered,0.001,1,31,0,-,virtual_delta_bytes,32768000.000 +csv,M,C-eager,clustered,0.001,1,31,0,-,rss_delta_bytes,32813056.000 +csv,M,C-eager,clustered,0.001,1,31,0,-,minor_faults,8001.000 +csv,M,C-eager,clustered,0.001,1,31,0,-,seal_ns_per_dirty,14931.080 +csv,M,S,clustered,0.001,1,31,0,-,virtual_delta_bytes,0.000 +csv,M,S,clustered,0.001,1,31,0,-,rss_delta_bytes,86016.000 +csv,M,S,clustered,0.001,1,31,0,-,minor_faults,11.000 +csv,M,S,clustered,0.001,1,31,0,-,seal_ns_per_dirty,23.958 +csv,M,-,clustered,0.001,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,clustered,0.001,8,31,0,-,payload_bytes,235520.000 +csv,M,-,clustered,0.001,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,clustered,0.001,8,31,0,-,sparse_persist_bytes,294400.000 +csv,M,C-lazy,clustered,0.001,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-lazy,clustered,0.001,8,31,0,-,rss_delta_bytes,4296704.000 +csv,M,C-lazy,clustered,0.001,8,31,0,-,minor_faults,1039.000 +csv,M,C-lazy,clustered,0.001,8,31,0,-,seal_ns_per_dirty,316.098 +csv,M,C-eager,clustered,0.001,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-eager,clustered,0.001,8,31,0,-,rss_delta_bytes,262144000.000 +csv,M,C-eager,clustered,0.001,8,31,0,-,minor_faults,63990.000 +csv,M,C-eager,clustered,0.001,8,31,0,-,seal_ns_per_dirty,11755.196 +csv,M,S,clustered,0.001,8,31,0,-,virtual_delta_bytes,270336.000 +csv,M,S,clustered,0.001,8,31,0,-,rss_delta_bytes,356352.000 +csv,M,S,clustered,0.001,8,31,0,-,minor_faults,77.000 +csv,M,S,clustered,0.001,8,31,0,-,seal_ns_per_dirty,22.755 +csv,M,-,clustered,0.001,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,clustered,0.001,64,31,0,-,payload_bytes,2004992.000 +csv,M,-,clustered,0.001,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,clustered,0.001,64,31,0,-,sparse_persist_bytes,2506240.000 +csv,M,C-lazy,clustered,0.001,64,31,0,-,virtual_delta_bytes,2104958976.000 +csv,M,C-lazy,clustered,0.001,64,31,0,-,rss_delta_bytes,34627584.000 +csv,M,C-lazy,clustered,0.001,64,31,0,-,minor_faults,8444.000 +csv,M,C-lazy,clustered,0.001,64,31,0,-,seal_ns_per_dirty,230.661 +csv,M,C-eager,clustered,0.001,64,31,0,-,virtual_delta_bytes,2104958976.000 +csv,M,C-eager,clustered,0.001,64,31,0,-,rss_delta_bytes,2096820224.000 +csv,M,C-eager,clustered,0.001,64,31,0,-,minor_faults,511909.000 +csv,M,C-eager,clustered,0.001,64,31,0,-,seal_ns_per_dirty,10421.367 +csv,M,S,clustered,0.001,64,31,0,-,virtual_delta_bytes,2703360.000 +csv,M,S,clustered,0.001,64,31,0,-,rss_delta_bytes,2695168.000 +csv,M,S,clustered,0.001,64,31,0,-,minor_faults,648.000 +csv,M,S,clustered,0.001,64,31,0,-,seal_ns_per_dirty,26.339 +csv,M,-,clustered,0.01,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,clustered,0.01,1,31,0,-,payload_bytes,306176.000 +csv,M,-,clustered,0.01,1,31,0,-,presence_bytes,253952.000 +csv,M,-,clustered,0.01,1,31,0,-,sparse_persist_bytes,382720.000 +csv,M,C-lazy,clustered,0.01,1,31,0,-,virtual_delta_bytes,32907264.000 +csv,M,C-lazy,clustered,0.01,1,31,0,-,rss_delta_bytes,1986560.000 +csv,M,C-lazy,clustered,0.01,1,31,0,-,minor_faults,475.000 +csv,M,C-lazy,clustered,0.01,1,31,0,-,seal_ns_per_dirty,94.743 +csv,M,C-eager,clustered,0.01,1,31,0,-,virtual_delta_bytes,32907264.000 +csv,M,C-eager,clustered,0.01,1,31,0,-,rss_delta_bytes,32808960.000 +csv,M,C-eager,clustered,0.01,1,31,0,-,minor_faults,8000.000 +csv,M,C-eager,clustered,0.01,1,31,0,-,seal_ns_per_dirty,1140.516 +csv,M,S,clustered,0.01,1,31,0,-,virtual_delta_bytes,405504.000 +csv,M,S,clustered,0.01,1,31,0,-,rss_delta_bytes,434176.000 +csv,M,S,clustered,0.01,1,31,0,-,minor_faults,96.000 +csv,M,S,clustered,0.01,1,31,0,-,seal_ns_per_dirty,16.150 +csv,M,-,clustered,0.01,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,clustered,0.01,8,31,0,-,payload_bytes,2548736.000 +csv,M,-,clustered,0.01,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,clustered,0.01,8,31,0,-,sparse_persist_bytes,3185920.000 +csv,M,C-lazy,clustered,0.01,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-lazy,clustered,0.01,8,31,0,-,rss_delta_bytes,15695872.000 +csv,M,C-lazy,clustered,0.01,8,31,0,-,minor_faults,3822.000 +csv,M,C-lazy,clustered,0.01,8,31,0,-,seal_ns_per_dirty,74.198 +csv,M,C-eager,clustered,0.01,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-eager,clustered,0.01,8,31,0,-,rss_delta_bytes,262152192.000 +csv,M,C-eager,clustered,0.01,8,31,0,-,minor_faults,63992.000 +csv,M,C-eager,clustered,0.01,8,31,0,-,seal_ns_per_dirty,1089.150 +csv,M,S,clustered,0.01,8,31,0,-,virtual_delta_bytes,3186688.000 +csv,M,S,clustered,0.01,8,31,0,-,rss_delta_bytes,3248128.000 +csv,M,S,clustered,0.01,8,31,0,-,minor_faults,783.000 +csv,M,S,clustered,0.01,8,31,0,-,seal_ns_per_dirty,18.179 +csv,M,-,clustered,0.01,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,clustered,0.01,64,31,0,-,payload_bytes,20876288.000 +csv,M,-,clustered,0.01,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,clustered,0.01,64,31,0,-,sparse_persist_bytes,26095360.000 +csv,M,C-lazy,clustered,0.01,64,31,0,-,virtual_delta_bytes,2104799232.000 +csv,M,C-lazy,clustered,0.01,64,31,0,-,rss_delta_bytes,126128128.000 +csv,M,C-lazy,clustered,0.01,64,31,0,-,minor_faults,30783.000 +csv,M,C-lazy,clustered,0.01,64,31,0,-,seal_ns_per_dirty,85.423 +csv,M,C-eager,clustered,0.01,64,31,0,-,virtual_delta_bytes,2104799232.000 +csv,M,C-eager,clustered,0.01,64,31,0,-,rss_delta_bytes,2096869376.000 +csv,M,C-eager,clustered,0.01,64,31,0,-,minor_faults,511921.000 +csv,M,C-eager,clustered,0.01,64,31,0,-,seal_ns_per_dirty,1053.586 +csv,M,S,clustered,0.01,64,31,0,-,virtual_delta_bytes,26271744.000 +csv,M,S,clustered,0.01,64,31,0,-,rss_delta_bytes,26300416.000 +csv,M,S,clustered,0.01,64,31,0,-,minor_faults,6411.000 +csv,M,S,clustered,0.01,64,31,0,-,seal_ns_per_dirty,27.974 +csv,M,-,clustered,0.1,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,clustered,0.1,1,31,0,-,payload_bytes,3245056.000 +csv,M,-,clustered,0.1,1,31,0,-,presence_bytes,253952.000 +csv,M,-,clustered,0.1,1,31,0,-,sparse_persist_bytes,4056320.000 +csv,M,C-lazy,clustered,0.1,1,31,0,-,virtual_delta_bytes,32911360.000 +csv,M,C-lazy,clustered,0.1,1,31,0,-,rss_delta_bytes,13684736.000 +csv,M,C-lazy,clustered,0.1,1,31,0,-,minor_faults,3331.000 +csv,M,C-lazy,clustered,0.1,1,31,0,-,seal_ns_per_dirty,72.623 +csv,M,C-eager,clustered,0.1,1,31,0,-,virtual_delta_bytes,32911360.000 +csv,M,C-eager,clustered,0.1,1,31,0,-,rss_delta_bytes,32821248.000 +csv,M,C-eager,clustered,0.1,1,31,0,-,minor_faults,8003.000 +csv,M,C-eager,clustered,0.1,1,31,0,-,seal_ns_per_dirty,139.820 +csv,M,S,clustered,0.1,1,31,0,-,virtual_delta_bytes,4116480.000 +csv,M,S,clustered,0.1,1,31,0,-,rss_delta_bytes,4108288.000 +csv,M,S,clustered,0.1,1,31,0,-,minor_faults,993.000 +csv,M,S,clustered,0.1,1,31,0,-,seal_ns_per_dirty,26.621 +csv,M,-,clustered,0.1,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,clustered,0.1,8,31,0,-,payload_bytes,25810944.000 +csv,M,-,clustered,0.1,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,clustered,0.1,8,31,0,-,sparse_persist_bytes,32263680.000 +csv,M,C-lazy,clustered,0.1,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-lazy,clustered,0.1,8,31,0,-,rss_delta_bytes,109027328.000 +csv,M,C-lazy,clustered,0.1,8,31,0,-,minor_faults,26608.000 +csv,M,C-lazy,clustered,0.1,8,31,0,-,seal_ns_per_dirty,50.459 +csv,M,C-eager,clustered,0.1,8,31,0,-,virtual_delta_bytes,263135232.000 +csv,M,C-eager,clustered,0.1,8,31,0,-,rss_delta_bytes,262225920.000 +csv,M,C-eager,clustered,0.1,8,31,0,-,minor_faults,64010.000 +csv,M,C-eager,clustered,0.1,8,31,0,-,seal_ns_per_dirty,105.524 +csv,M,S,clustered,0.1,8,31,0,-,virtual_delta_bytes,32399360.000 +csv,M,S,clustered,0.1,8,31,0,-,rss_delta_bytes,32333824.000 +csv,M,S,clustered,0.1,8,31,0,-,minor_faults,7884.000 +csv,M,S,clustered,0.1,8,31,0,-,seal_ns_per_dirty,19.254 +csv,M,-,clustered,0.1,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,clustered,0.1,64,31,0,-,payload_bytes,207740928.000 +csv,M,-,clustered,0.1,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,clustered,0.1,64,31,0,-,sparse_persist_bytes,259676160.000 +csv,M,C-lazy,clustered,0.1,64,31,0,-,virtual_delta_bytes,2104971264.000 +csv,M,C-lazy,clustered,0.1,64,31,0,-,rss_delta_bytes,871952384.000 +csv,M,C-lazy,clustered,0.1,64,31,0,-,minor_faults,212869.000 +csv,M,C-lazy,clustered,0.1,64,31,0,-,seal_ns_per_dirty,52.776 +csv,M,C-eager,clustered,0.1,64,31,0,-,virtual_delta_bytes,2104971264.000 +csv,M,C-eager,clustered,0.1,64,31,0,-,rss_delta_bytes,2097557504.000 +csv,M,C-eager,clustered,0.1,64,31,0,-,minor_faults,512089.000 +csv,M,C-eager,clustered,0.1,64,31,0,-,seal_ns_per_dirty,107.888 +csv,M,S,clustered,0.1,64,31,0,-,virtual_delta_bytes,259887104.000 +csv,M,S,clustered,0.1,64,31,0,-,rss_delta_bytes,259899392.000 +csv,M,S,clustered,0.1,64,31,0,-,minor_faults,63442.000 +csv,M,S,clustered,0.1,64,31,0,-,seal_ns_per_dirty,18.164 +csv,M,-,clustered,1,1,31,0,-,logical_bytes,32505856.000 +csv,M,-,clustered,1,1,31,0,-,payload_bytes,32505856.000 +csv,M,-,clustered,1,1,31,0,-,presence_bytes,253952.000 +csv,M,-,clustered,1,1,31,0,-,sparse_persist_bytes,40632320.000 +csv,M,C-lazy,clustered,1,1,31,0,-,virtual_delta_bytes,32768000.000 +csv,M,C-lazy,clustered,1,1,31,0,-,rss_delta_bytes,32874496.000 +csv,M,C-lazy,clustered,1,1,31,0,-,minor_faults,8016.000 +csv,M,C-lazy,clustered,1,1,31,0,-,seal_ns_per_dirty,19.355 +csv,M,C-eager,clustered,1,1,31,0,-,virtual_delta_bytes,32768000.000 +csv,M,C-eager,clustered,1,1,31,0,-,rss_delta_bytes,32874496.000 +csv,M,C-eager,clustered,1,1,31,0,-,minor_faults,8016.000 +csv,M,C-eager,clustered,1,1,31,0,-,seal_ns_per_dirty,14.693 +csv,M,S,clustered,1,1,31,0,-,virtual_delta_bytes,40886272.000 +csv,M,S,clustered,1,1,31,0,-,rss_delta_bytes,40935424.000 +csv,M,S,clustered,1,1,31,0,-,minor_faults,9984.000 +csv,M,S,clustered,1,1,31,0,-,seal_ns_per_dirty,23.132 +csv,M,-,clustered,1,8,31,0,-,logical_bytes,260046848.000 +csv,M,-,clustered,1,8,31,0,-,payload_bytes,260046848.000 +csv,M,-,clustered,1,8,31,0,-,presence_bytes,2031616.000 +csv,M,-,clustered,1,8,31,0,-,sparse_persist_bytes,325058560.000 +csv,M,C-lazy,clustered,1,8,31,0,-,virtual_delta_bytes,262991872.000 +csv,M,C-lazy,clustered,1,8,31,0,-,rss_delta_bytes,263094272.000 +csv,M,C-lazy,clustered,1,8,31,0,-,minor_faults,64222.000 +csv,M,C-lazy,clustered,1,8,31,0,-,seal_ns_per_dirty,16.713 +csv,M,C-eager,clustered,1,8,31,0,-,virtual_delta_bytes,262991872.000 +csv,M,C-eager,clustered,1,8,31,0,-,rss_delta_bytes,263094272.000 +csv,M,C-eager,clustered,1,8,31,0,-,minor_faults,64222.000 +csv,M,C-eager,clustered,1,8,31,0,-,seal_ns_per_dirty,16.260 +csv,M,S,clustered,1,8,31,0,-,virtual_delta_bytes,327090176.000 +csv,M,S,clustered,1,8,31,0,-,rss_delta_bytes,327139328.000 +csv,M,S,clustered,1,8,31,0,-,minor_faults,79858.000 +csv,M,S,clustered,1,8,31,0,-,seal_ns_per_dirty,19.726 +csv,M,-,clustered,1,64,31,0,-,logical_bytes,2080374784.000 +csv,M,-,clustered,1,64,31,0,-,payload_bytes,2080374784.000 +csv,M,-,clustered,1,64,31,0,-,presence_bytes,16252928.000 +csv,M,-,clustered,1,64,31,0,-,sparse_persist_bytes,2600468480.000 +csv,M,C-lazy,clustered,1,64,31,0,-,virtual_delta_bytes,2104803328.000 +csv,M,C-lazy,clustered,1,64,31,0,-,rss_delta_bytes,2104807424.000 +csv,M,C-lazy,clustered,1,64,31,0,-,minor_faults,513859.000 +csv,M,C-lazy,clustered,1,64,31,0,-,seal_ns_per_dirty,14.611 +csv,M,C-eager,clustered,1,64,31,0,-,virtual_delta_bytes,2104803328.000 +csv,M,C-eager,clustered,1,64,31,0,-,rss_delta_bytes,2104807424.000 +csv,M,C-eager,clustered,1,64,31,0,-,minor_faults,513859.000 +csv,M,C-eager,clustered,1,64,31,0,-,seal_ns_per_dirty,16.674 +csv,M,S,clustered,1,64,31,0,-,virtual_delta_bytes,2616721408.000 +csv,M,S,clustered,1,64,31,0,-,rss_delta_bytes,2616770560.000 +csv,M,S,clustered,1,64,31,0,-,minor_faults,638850.000 +csv,M,S,clustered,1,64,31,0,-,seal_ns_per_dirty,25.714 +``` + +```csv +csv,strategy,pattern,density,k,style,rows_emitted,bytes_read,iops,requests,rows_scanned,ranges_scanned,wall_us +csv,unmasked,uniform,0.001,1,heuristic,65536,127296,1,1,65536,1,20360.7 +csv,combined,uniform,0.001,1,heuristic,46,97424,6,1,46,46,1902.8 +csv,independent,uniform,0.001,1,heuristic,46,97424,6,1,46,46,1731.5 +csv,unmasked,uniform,0.001,1,all_late,65536,127296,1,1,65536,1,17898.6 +csv,combined,uniform,0.001,1,all_late,46,97424,6,1,46,46,2204.8 +csv,independent,uniform,0.001,1,all_late,46,97424,6,1,46,46,1895.5 +csv,unmasked,uniform,0.001,1,all_early,65536,127296,1,1,65536,1,18245.1 +csv,combined,uniform,0.001,1,all_early,46,97424,6,1,46,46,1786.5 +csv,independent,uniform,0.001,1,all_early,46,97424,6,1,46,46,1694.8 +csv,unmasked,uniform,0.001,2,heuristic,65536,131560,1,1,65536,1,19577.3 +csv,combined,uniform,0.001,2,heuristic,1,6536,2,1,1,1,1441.1 +csv,independent,uniform,0.001,2,heuristic,112,202952,11,2,112,112,3531.2 +csv,unmasked,uniform,0.001,2,all_late,65536,131560,1,1,65536,1,21931.8 +csv,combined,uniform,0.001,2,all_late,1,6536,2,1,1,1,1391.8 +csv,independent,uniform,0.001,2,all_late,112,202952,11,2,112,112,3962.0 +csv,unmasked,uniform,0.001,2,all_early,65536,131560,1,1,65536,1,21526.9 +csv,combined,uniform,0.001,2,all_early,1,6536,2,1,1,1,1404.4 +csv,independent,uniform,0.001,2,all_early,112,202952,11,2,112,112,3962.1 +csv,unmasked,uniform,0.001,4,heuristic,65536,140808,1,1,65536,1,44787.4 +csv,combined,uniform,0.001,4,heuristic,0,0,0,0,0,0,458.9 +csv,independent,uniform,0.001,4,heuristic,245,419424,23,4,245,245,6882.4 +csv,unmasked,uniform,0.001,4,all_late,65536,140808,1,1,65536,1,32817.0 +csv,combined,uniform,0.001,4,all_late,0,0,0,0,0,0,437.1 +csv,independent,uniform,0.001,4,all_late,245,419424,23,4,245,245,7015.5 +csv,unmasked,uniform,0.001,4,all_early,65536,140808,1,1,65536,1,35108.5 +csv,combined,uniform,0.001,4,all_early,0,0,0,0,0,0,417.8 +csv,independent,uniform,0.001,4,all_early,245,419424,23,4,245,245,7220.3 +csv,unmasked,uniform,0.001,8,heuristic,65536,159736,1,1,65536,1,50479.8 +csv,combined,uniform,0.001,8,heuristic,0,0,0,0,0,0,689.6 +csv,independent,uniform,0.001,8,heuristic,531,849024,42,8,531,530,14723.7 +csv,unmasked,uniform,0.001,8,all_late,65536,159736,1,1,65536,1,55928.1 +csv,combined,uniform,0.001,8,all_late,0,0,0,0,0,0,534.7 +csv,independent,uniform,0.001,8,all_late,531,849024,42,8,531,530,12213.7 +csv,unmasked,uniform,0.001,8,all_early,65536,159736,1,1,65536,1,45996.3 +csv,combined,uniform,0.001,8,all_early,0,0,0,0,0,0,807.1 +csv,independent,uniform,0.001,8,all_early,531,849024,42,8,531,530,15941.2 +csv,unmasked,uniform,0.01,1,heuristic,65536,136160,1,1,65536,1,17418.8 +csv,combined,uniform,0.01,1,heuristic,692,136160,1,1,692,689,2237.7 +csv,independent,uniform,0.01,1,heuristic,692,136160,1,1,692,689,2059.0 +csv,unmasked,uniform,0.01,1,all_late,65536,136160,1,1,65536,1,16628.3 +csv,combined,uniform,0.01,1,all_late,692,136160,1,1,692,689,3109.5 +csv,independent,uniform,0.01,1,all_late,692,136160,1,1,692,689,2976.2 +csv,unmasked,uniform,0.01,1,all_early,65536,136160,1,1,65536,1,20721.0 +csv,combined,uniform,0.01,1,all_early,692,136160,1,1,692,689,2864.6 +csv,independent,uniform,0.01,1,all_early,692,136160,1,1,692,689,2694.1 +csv,unmasked,uniform,0.01,2,heuristic,65536,147720,2,1,65536,1,18435.6 +csv,combined,uniform,0.01,2,heuristic,9,30920,10,1,9,9,2419.7 +csv,independent,uniform,0.01,2,heuristic,1354,271752,3,2,1354,1341,7810.5 +csv,unmasked,uniform,0.01,2,all_late,65536,147720,2,1,65536,1,22980.0 +csv,combined,uniform,0.01,2,all_late,9,30920,10,1,9,9,1755.1 +csv,independent,uniform,0.01,2,all_late,1354,271752,3,2,1354,1341,5014.4 +csv,unmasked,uniform,0.01,2,all_early,65536,147720,2,1,65536,1,24046.7 +csv,combined,uniform,0.01,2,all_early,9,30920,10,1,9,9,1828.5 +csv,independent,uniform,0.01,2,all_early,1354,271752,3,2,1354,1341,4873.7 +csv,unmasked,uniform,0.01,4,heuristic,65536,170624,4,1,65536,1,28349.1 +csv,combined,uniform,0.01,4,heuristic,0,0,0,0,0,0,587.8 +csv,independent,uniform,0.01,4,heuristic,2655,542720,7,4,2655,2635,11765.9 +csv,unmasked,uniform,0.01,4,all_late,65536,170624,4,1,65536,1,23478.2 +csv,combined,uniform,0.01,4,all_late,0,0,0,0,0,0,436.3 +csv,independent,uniform,0.01,4,all_late,2655,542720,7,4,2655,2635,11137.5 +csv,unmasked,uniform,0.01,4,all_early,65536,170624,4,1,65536,1,24283.6 +csv,combined,uniform,0.01,4,all_early,0,0,0,0,0,0,401.9 +csv,independent,uniform,0.01,4,all_early,2655,542720,7,4,2655,2635,9056.0 +csv,unmasked,uniform,0.01,8,heuristic,65536,217040,8,1,65536,1,43979.9 +csv,combined,uniform,0.01,8,heuristic,0,0,0,0,0,0,579.0 +csv,independent,uniform,0.01,8,heuristic,5304,1085264,15,8,5304,5266,23243.7 +csv,unmasked,uniform,0.01,8,all_late,65536,217040,8,1,65536,1,52073.5 +csv,combined,uniform,0.01,8,all_late,0,0,0,0,0,0,617.8 +csv,independent,uniform,0.01,8,all_late,5304,1085264,15,8,5304,5266,18135.3 +csv,unmasked,uniform,0.01,8,all_early,65536,217040,8,1,65536,1,43520.5 +csv,combined,uniform,0.01,8,all_early,0,0,0,0,0,0,546.6 +csv,independent,uniform,0.01,8,all_early,5304,1085264,15,8,5304,5266,24799.9 +csv,unmasked,uniform,0.1,1,heuristic,65536,195416,1,1,65536,1,22045.2 +csv,combined,uniform,0.1,1,heuristic,6606,195416,1,1,6606,5937,6994.0 +csv,independent,uniform,0.1,1,heuristic,6606,195416,1,1,6606,5937,7034.8 +csv,unmasked,uniform,0.1,1,all_late,65536,195416,1,1,65536,1,17042.9 +csv,combined,uniform,0.1,1,all_late,6606,195416,1,1,6606,5937,7443.2 +csv,independent,uniform,0.1,1,all_late,6606,195416,1,1,6606,5937,8357.6 +csv,unmasked,uniform,0.1,1,all_early,65536,195416,1,1,65536,1,20993.0 +csv,combined,uniform,0.1,1,all_early,6606,195416,1,1,6606,5937,8500.6 +csv,independent,uniform,0.1,1,all_early,6606,195416,1,1,6606,5937,8234.3 +csv,unmasked,uniform,0.1,2,heuristic,65536,266584,2,1,65536,1,21163.7 +csv,combined,uniform,0.1,2,heuristic,679,266584,2,1,679,672,3197.9 +csv,independent,uniform,0.1,2,heuristic,13194,390616,3,2,13194,11864,14780.0 +csv,unmasked,uniform,0.1,2,all_late,65536,266584,2,1,65536,1,19575.8 +csv,combined,uniform,0.1,2,all_late,679,266584,2,1,679,672,3174.1 +csv,independent,uniform,0.1,2,all_late,13194,390616,3,2,13194,11864,16857.3 +csv,unmasked,uniform,0.1,2,all_early,65536,266584,2,1,65536,1,21175.7 +csv,combined,uniform,0.1,2,all_early,679,266584,2,1,679,672,3291.7 +csv,independent,uniform,0.1,2,all_early,13194,390616,3,2,13194,11864,14129.9 +csv,unmasked,uniform,0.1,4,heuristic,65536,409560,4,1,65536,1,26193.7 +csv,combined,uniform,0.1,4,heuristic,8,143320,18,1,8,8,2734.8 +csv,independent,uniform,0.1,4,heuristic,26435,781656,7,4,26435,23772,28000.3 +csv,unmasked,uniform,0.1,4,all_late,65536,409560,4,1,65536,1,24184.1 +csv,combined,uniform,0.1,4,all_late,8,143320,18,1,8,8,2501.0 +csv,independent,uniform,0.1,4,all_late,26435,781656,7,4,26435,23772,29428.7 +csv,unmasked,uniform,0.1,4,all_early,65536,409560,4,1,65536,1,24306.0 +csv,combined,uniform,0.1,4,all_early,8,143320,18,1,8,8,2528.9 +csv,independent,uniform,0.1,4,all_early,26435,781656,7,4,26435,23772,33150.1 +csv,unmasked,uniform,0.1,8,heuristic,65536,692016,8,1,65536,1,50364.8 +csv,combined,uniform,0.1,8,heuristic,0,0,0,0,0,0,528.9 +csv,independent,uniform,0.1,8,heuristic,52513,1560240,15,8,52513,47298,64182.2 +csv,unmasked,uniform,0.1,8,all_late,65536,692016,8,1,65536,1,46960.8 +csv,combined,uniform,0.1,8,all_late,0,0,0,0,0,0,497.5 +csv,independent,uniform,0.1,8,all_late,52513,1560240,15,8,52513,47298,61958.8 +csv,unmasked,uniform,0.1,8,all_early,65536,692016,8,1,65536,1,44671.3 +csv,combined,uniform,0.1,8,all_early,0,0,0,0,0,0,670.2 +csv,independent,uniform,0.1,8,all_early,52513,1560240,15,8,52513,47298,59927.2 +csv,unmasked,uniform,0.5,1,heuristic,65536,1208448,1,1,65536,1,18860.6 +csv,combined,uniform,0.5,1,heuristic,33120,1208448,1,1,33120,16289,20881.7 +csv,independent,uniform,0.5,1,heuristic,33120,1208448,1,1,33120,16289,22606.5 +csv,unmasked,uniform,0.5,1,all_late,65536,1208448,1,1,65536,1,19585.1 +csv,combined,uniform,0.5,1,all_late,33120,1208448,1,1,33120,16289,18725.9 +csv,independent,uniform,0.5,1,all_late,33120,1208448,1,1,33120,16289,21411.1 +csv,unmasked,uniform,0.5,1,all_early,65536,1208448,1,1,65536,1,17377.9 +csv,combined,uniform,0.5,1,all_early,33120,1208448,1,1,33120,16289,19883.6 +csv,independent,uniform,0.5,1,all_early,33120,1208448,1,1,33120,16289,19130.6 +csv,unmasked,uniform,0.5,2,heuristic,65536,2292864,1,1,65536,1,21271.1 +csv,combined,uniform,0.5,2,heuristic,16591,2292864,1,1,16591,12357,18149.8 +csv,independent,uniform,0.5,2,heuristic,65891,2415872,3,2,65891,32770,43607.9 +csv,unmasked,uniform,0.5,2,all_late,65536,2292864,1,1,65536,1,22177.3 +csv,combined,uniform,0.5,2,all_late,16591,2292864,1,1,16591,12357,20511.2 +csv,independent,uniform,0.5,2,all_late,65891,2415872,3,2,65891,32770,41180.7 +csv,unmasked,uniform,0.5,2,all_early,65536,2292864,1,1,65536,1,22188.9 +csv,combined,uniform,0.5,2,all_early,16591,2292864,1,1,16591,12357,15729.0 +csv,independent,uniform,0.5,2,all_early,65891,2415872,3,2,65891,32770,39933.7 +csv,unmasked,uniform,0.5,4,heuristic,65536,2541824,2,1,65536,1,29479.1 +csv,combined,uniform,0.5,4,heuristic,4074,2541824,2,1,4074,3809,11879.6 +csv,independent,uniform,0.5,4,heuristic,131294,2912640,7,4,131294,65436,79249.0 +csv,unmasked,uniform,0.5,4,all_late,65536,2541824,2,1,65536,1,30822.9 +csv,combined,uniform,0.5,4,all_late,4074,2541824,2,1,4074,3809,12342.1 +csv,independent,uniform,0.5,4,all_late,131294,2912640,7,4,131294,65436,78326.7 +csv,unmasked,uniform,0.5,4,all_early,65536,2541824,2,1,65536,1,25393.9 +csv,combined,uniform,0.5,4,all_early,4074,2541824,2,1,4074,3809,11960.8 +csv,independent,uniform,0.5,4,all_early,131294,2912640,7,4,131294,65436,74817.5 +csv,unmasked,uniform,0.5,8,heuristic,65536,4958336,5,1,65536,1,39019.6 +csv,combined,uniform,0.5,8,heuristic,247,3195520,272,1,247,246,11241.5 +csv,independent,uniform,0.5,8,heuristic,261893,5824256,15,8,261893,131042,167084.9 +csv,unmasked,uniform,0.5,8,all_late,65536,4958336,5,1,65536,1,41161.9 +csv,combined,uniform,0.5,8,all_late,247,3195520,272,1,247,246,12822.9 +csv,independent,uniform,0.5,8,all_late,261893,5824256,15,8,261893,131042,179208.7 +csv,unmasked,uniform,0.5,8,all_early,65536,4958336,5,1,65536,1,35608.5 +csv,combined,uniform,0.5,8,all_early,247,3195520,272,1,247,246,11137.6 +csv,independent,uniform,0.5,8,all_early,261893,5824256,15,8,261893,131042,171670.5 +csv,unmasked,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,17435.7 +csv,combined,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,21705.7 +csv,independent,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,21128.8 +csv,unmasked,uniform,1,1,all_late,65536,1175680,1,1,65536,1,15722.4 +csv,combined,uniform,1,1,all_late,65536,1175680,1,1,65536,1,20612.1 +csv,independent,uniform,1,1,all_late,65536,1175680,1,1,65536,1,20793.1 +csv,unmasked,uniform,1,1,all_early,65536,1175680,1,1,65536,1,20284.3 +csv,combined,uniform,1,1,all_early,65536,1175680,1,1,65536,1,23424.4 +csv,independent,uniform,1,1,all_early,65536,1175680,1,1,65536,1,22368.9 +csv,unmasked,uniform,1,2,heuristic,65536,2227328,1,1,65536,1,20554.8 +csv,combined,uniform,1,2,heuristic,65536,2227328,1,1,65536,1,30818.6 +csv,independent,uniform,1,2,heuristic,131072,2350336,3,2,131072,2,44391.0 +csv,unmasked,uniform,1,2,all_late,65536,2227328,1,1,65536,1,19361.0 +csv,combined,uniform,1,2,all_late,65536,2227328,1,1,65536,1,24504.7 +csv,independent,uniform,1,2,all_late,131072,2350336,3,2,131072,2,43616.7 +csv,unmasked,uniform,1,2,all_early,65536,2227328,1,1,65536,1,19477.3 +csv,combined,uniform,1,2,all_early,65536,2227328,1,1,65536,1,23519.7 +csv,independent,uniform,1,2,all_early,131072,2350336,3,2,131072,2,43864.3 +csv,unmasked,uniform,1,4,heuristic,65536,4330624,1,1,65536,1,22930.6 +csv,combined,uniform,1,4,heuristic,65536,4330624,1,1,65536,1,27403.2 +csv,independent,uniform,1,4,heuristic,262144,4699648,7,4,262144,4,87672.9 +csv,unmasked,uniform,1,4,all_late,65536,4330624,1,1,65536,1,23857.0 +csv,combined,uniform,1,4,all_late,65536,4330624,1,1,65536,1,31823.7 +csv,independent,uniform,1,4,all_late,262144,4699648,7,4,262144,4,84710.5 +csv,unmasked,uniform,1,4,all_early,65536,4330624,1,1,65536,1,24905.0 +csv,combined,uniform,1,4,all_early,65536,4330624,1,1,65536,1,30601.5 +csv,independent,uniform,1,4,all_early,262144,4699648,7,4,262144,4,88719.6 +csv,unmasked,uniform,1,8,heuristic,65536,8535168,3,2,65536,1,33333.5 +csv,combined,uniform,1,8,heuristic,65536,8535168,3,2,65536,1,38368.6 +csv,independent,uniform,1,8,heuristic,524288,9398272,15,8,524288,8,192389.5 +csv,unmasked,uniform,1,8,all_late,65536,8535168,3,2,65536,1,29281.4 +csv,combined,uniform,1,8,all_late,65536,8535168,3,2,65536,1,33361.2 +csv,independent,uniform,1,8,all_late,524288,9398272,15,8,524288,8,184600.6 +csv,unmasked,uniform,1,8,all_early,65536,8535168,3,2,65536,1,31409.1 +csv,combined,uniform,1,8,all_early,65536,8535168,3,2,65536,1,34904.2 +csv,independent,uniform,1,8,all_early,524288,9398272,15,8,524288,8,186247.6 +csv,unmasked,clustered,0.001,1,heuristic,65536,127744,1,1,65536,1,17288.7 +csv,combined,clustered,0.001,1,heuristic,64,3000,2,1,64,1,1349.7 +csv,independent,clustered,0.001,1,heuristic,64,3000,2,1,64,1,1393.8 +csv,unmasked,clustered,0.001,1,all_late,65536,127744,1,1,65536,1,17680.3 +csv,combined,clustered,0.001,1,all_late,64,3000,2,1,64,1,1134.5 +csv,independent,clustered,0.001,1,all_late,64,3000,2,1,64,1,1200.0 +csv,unmasked,clustered,0.001,1,all_early,65536,127744,1,1,65536,1,17862.3 +csv,combined,clustered,0.001,1,all_early,64,3000,2,1,64,1,1240.1 +csv,independent,clustered,0.001,1,all_early,64,3000,2,1,64,1,1217.3 +csv,unmasked,clustered,0.001,2,heuristic,65536,132552,1,1,65536,1,18578.6 +csv,combined,clustered,0.001,2,heuristic,0,0,0,0,0,0,349.3 +csv,independent,clustered,0.001,2,heuristic,128,6008,4,2,128,2,2546.5 +csv,unmasked,clustered,0.001,2,all_late,65536,132552,1,1,65536,1,18705.1 +csv,combined,clustered,0.001,2,all_late,0,0,0,0,0,0,444.7 +csv,independent,clustered,0.001,2,all_late,128,6008,4,2,128,2,2665.6 +csv,unmasked,clustered,0.001,2,all_early,65536,132552,1,1,65536,1,19036.3 +csv,combined,clustered,0.001,2,all_early,0,0,0,0,0,0,323.1 +csv,independent,clustered,0.001,2,all_early,128,6008,4,2,128,2,2575.0 +csv,unmasked,clustered,0.001,4,heuristic,65536,143048,1,1,65536,1,21828.1 +csv,combined,clustered,0.001,4,heuristic,0,0,0,0,0,0,439.8 +csv,independent,clustered,0.001,4,heuristic,320,14184,9,4,320,5,4593.2 +csv,unmasked,clustered,0.001,4,all_late,65536,143048,1,1,65536,1,32846.8 +csv,combined,clustered,0.001,4,all_late,0,0,0,0,0,0,407.9 +csv,independent,clustered,0.001,4,all_late,320,14184,9,4,320,5,5826.8 +csv,unmasked,clustered,0.001,4,all_early,65536,143048,1,1,65536,1,22800.2 +csv,combined,clustered,0.001,4,all_early,0,0,0,0,0,0,445.2 +csv,independent,clustered,0.001,4,all_early,320,14184,9,4,320,5,5651.5 +csv,unmasked,clustered,0.001,8,heuristic,65536,153648,1,1,65536,1,28765.2 +csv,combined,clustered,0.001,8,heuristic,0,0,0,0,0,0,545.6 +csv,independent,clustered,0.001,8,heuristic,640,28664,16,6,640,10,10190.4 +csv,unmasked,clustered,0.001,8,all_late,65536,153648,1,1,65536,1,29569.5 +csv,combined,clustered,0.001,8,all_late,0,0,0,0,0,0,662.0 +csv,independent,clustered,0.001,8,all_late,640,28664,16,6,640,10,8867.6 +csv,unmasked,clustered,0.001,8,all_early,65536,153648,1,1,65536,1,28225.6 +csv,combined,clustered,0.001,8,all_early,0,0,0,0,0,0,538.6 +csv,independent,clustered,0.001,8,all_early,640,28664,16,6,640,10,8907.1 +csv,unmasked,clustered,0.01,1,heuristic,65536,130448,1,1,65536,1,16859.1 +csv,combined,clustered,0.01,1,heuristic,704,31504,6,1,704,11,1811.7 +csv,independent,clustered,0.01,1,heuristic,704,31504,6,1,704,11,1488.3 +csv,unmasked,clustered,0.01,1,all_late,65536,130448,1,1,65536,1,14315.9 +csv,combined,clustered,0.01,1,all_late,704,31504,6,1,704,11,1361.4 +csv,independent,clustered,0.01,1,all_late,704,31504,6,1,704,11,1395.5 +csv,unmasked,clustered,0.01,1,all_early,65536,130448,1,1,65536,1,15084.2 +csv,combined,clustered,0.01,1,all_early,704,31504,6,1,704,11,1493.1 +csv,independent,clustered,0.01,1,all_early,704,31504,6,1,704,11,1494.7 +csv,unmasked,clustered,0.01,2,heuristic,65536,135832,2,1,65536,1,18830.3 +csv,combined,clustered,0.01,2,heuristic,0,0,0,0,0,0,342.8 +csv,independent,clustered,0.01,2,heuristic,1216,50136,13,2,1216,19,2957.1 +csv,unmasked,clustered,0.01,2,all_late,65536,135832,2,1,65536,1,18595.7 +csv,combined,clustered,0.01,2,all_late,0,0,0,0,0,0,342.6 +csv,independent,clustered,0.01,2,all_late,1216,50136,13,2,1216,19,3758.7 +csv,unmasked,clustered,0.01,2,all_early,65536,135832,2,1,65536,1,24837.5 +csv,combined,clustered,0.01,2,all_early,0,0,0,0,0,0,369.2 +csv,independent,clustered,0.01,2,all_early,1216,50136,13,2,1216,19,4310.0 +csv,unmasked,clustered,0.01,4,heuristic,65536,145968,4,1,65536,1,31446.9 +csv,combined,clustered,0.01,4,heuristic,0,0,0,0,0,0,411.9 +csv,independent,clustered,0.01,4,heuristic,2112,91200,24,4,2112,33,6281.1 +csv,unmasked,clustered,0.01,4,all_late,65536,145968,4,1,65536,1,21663.8 +csv,combined,clustered,0.01,4,all_late,0,0,0,0,0,0,414.6 +csv,independent,clustered,0.01,4,all_late,2112,91200,24,4,2112,33,6084.2 +csv,unmasked,clustered,0.01,4,all_early,65536,145968,4,1,65536,1,22057.9 +csv,combined,clustered,0.01,4,all_early,0,0,0,0,0,0,471.5 +csv,independent,clustered,0.01,4,all_early,2112,91200,24,4,2112,33,5734.3 +csv,unmasked,clustered,0.01,8,heuristic,65536,169416,8,1,65536,1,28629.3 +csv,combined,clustered,0.01,8,heuristic,0,0,0,0,0,0,498.4 +csv,independent,clustered,0.01,8,heuristic,4544,214248,51,8,4544,71,14205.4 +csv,unmasked,clustered,0.01,8,all_late,65536,169416,8,1,65536,1,30549.0 +csv,combined,clustered,0.01,8,all_late,0,0,0,0,0,0,772.3 +csv,independent,clustered,0.01,8,all_late,4544,214248,51,8,4544,71,14172.8 +csv,unmasked,clustered,0.01,8,all_early,65536,169416,8,1,65536,1,27991.2 +csv,combined,clustered,0.01,8,all_early,0,0,0,0,0,0,534.8 +csv,independent,clustered,0.01,8,all_early,4544,214248,51,8,4544,71,12688.8 +csv,unmasked,clustered,0.1,1,heuristic,65536,159928,1,1,65536,1,17550.2 +csv,combined,clustered,0.1,1,heuristic,6528,153736,2,1,6528,93,3527.5 +csv,independent,clustered,0.1,1,heuristic,6528,153736,2,1,6528,93,3605.4 +csv,unmasked,clustered,0.1,1,all_late,65536,159928,1,1,65536,1,26734.2 +csv,combined,clustered,0.1,1,all_late,6528,153736,2,1,6528,93,3673.4 +csv,independent,clustered,0.1,1,all_late,6528,153736,2,1,6528,93,3525.3 +csv,unmasked,clustered,0.1,1,all_early,65536,159928,1,1,65536,1,17016.6 +csv,combined,clustered,0.1,1,all_early,6528,153736,2,1,6528,93,3702.6 +csv,independent,clustered,0.1,1,all_early,6528,153736,2,1,6528,93,3671.7 +csv,unmasked,clustered,0.1,2,heuristic,65536,194472,2,1,65536,1,18679.5 +csv,combined,clustered,0.1,2,heuristic,832,80512,10,1,832,13,1934.0 +csv,independent,clustered,0.1,2,heuristic,12800,308184,5,2,12800,183,6508.4 +csv,unmasked,clustered,0.1,2,all_late,65536,194472,2,1,65536,1,17450.5 +csv,combined,clustered,0.1,2,all_late,832,80512,10,1,832,13,1785.9 +csv,independent,clustered,0.1,2,all_late,12800,308184,5,2,12800,183,6609.4 +csv,unmasked,clustered,0.1,2,all_early,65536,194472,2,1,65536,1,18979.6 +csv,combined,clustered,0.1,2,all_early,832,80512,10,1,832,13,2304.7 +csv,independent,clustered,0.1,2,all_early,12800,308184,5,2,12800,183,9397.0 +csv,unmasked,clustered,0.1,4,heuristic,65536,263544,4,1,65536,1,23434.7 +csv,combined,clustered,0.1,4,heuristic,0,0,0,0,0,0,424.7 +csv,independent,clustered,0.1,4,heuristic,25344,619256,10,4,25344,361,13853.0 +csv,unmasked,clustered,0.1,4,all_late,65536,263544,4,1,65536,1,23291.2 +csv,combined,clustered,0.1,4,all_late,0,0,0,0,0,0,464.7 +csv,independent,clustered,0.1,4,all_late,25344,619256,10,4,25344,361,13137.1 +csv,unmasked,clustered,0.1,4,all_early,65536,263544,4,1,65536,1,22634.4 +csv,combined,clustered,0.1,4,all_early,0,0,0,0,0,0,396.5 +csv,independent,clustered,0.1,4,all_early,25344,619256,10,4,25344,361,13726.8 +csv,unmasked,clustered,0.1,8,heuristic,65536,406864,8,1,65536,1,29721.0 +csv,combined,clustered,0.1,8,heuristic,0,0,0,0,0,0,531.7 +csv,independent,clustered,0.1,8,heuristic,51456,1250448,20,8,51456,725,31067.3 +csv,unmasked,clustered,0.1,8,all_late,65536,406864,8,1,65536,1,30905.2 +csv,combined,clustered,0.1,8,all_late,0,0,0,0,0,0,723.6 +csv,independent,clustered,0.1,8,all_late,51456,1250448,20,8,51456,725,30954.9 +csv,unmasked,clustered,0.1,8,all_early,65536,406864,8,1,65536,1,31146.3 +csv,combined,clustered,0.1,8,all_early,0,0,0,0,0,0,593.9 +csv,independent,clustered,0.1,8,all_early,51456,1250448,20,8,51456,725,31975.3 +csv,unmasked,clustered,0.5,1,heuristic,65536,1180776,1,1,65536,1,17713.7 +csv,combined,clustered,0.5,1,heuristic,32512,1086016,21,1,32512,249,13810.5 +csv,independent,clustered,0.5,1,heuristic,32512,1086016,21,1,32512,249,14064.5 +csv,unmasked,clustered,0.5,1,all_late,65536,1180776,1,1,65536,1,18285.2 +csv,combined,clustered,0.5,1,all_late,32512,1086016,21,1,32512,249,13620.8 +csv,independent,clustered,0.5,1,all_late,32512,1086016,21,1,32512,249,12963.1 +csv,unmasked,clustered,0.5,1,all_early,65536,1180776,1,1,65536,1,18000.3 +csv,combined,clustered,0.5,1,all_early,32512,1086016,21,1,32512,249,12600.8 +csv,independent,clustered,0.5,1,all_early,32512,1086016,21,1,32512,249,12934.5 +csv,unmasked,clustered,0.5,2,heuristic,65536,1299824,1,1,65536,1,21886.1 +csv,combined,clustered,0.5,2,heuristic,15232,915328,62,1,15232,179,10748.3 +csv,independent,clustered,0.5,2,heuristic,64640,1328816,23,2,64640,509,27227.0 +csv,unmasked,clustered,0.5,2,all_late,65536,1299824,1,1,65536,1,20922.2 +csv,combined,clustered,0.5,2,all_late,15232,915328,62,1,15232,179,9633.0 +csv,independent,clustered,0.5,2,all_late,64640,1328816,23,2,64640,509,28997.0 +csv,unmasked,clustered,0.5,2,all_early,65536,1299824,1,1,65536,1,28517.0 +csv,combined,clustered,0.5,2,all_early,15232,915328,62,1,15232,179,9202.2 +csv,independent,clustered,0.5,2,all_early,64640,1328816,23,2,64640,509,28608.3 +csv,unmasked,clustered,0.5,4,heuristic,65536,2474528,3,1,65536,1,25104.4 +csv,combined,clustered,0.5,4,heuristic,3328,739232,92,1,3328,52,6431.5 +csv,independent,clustered,0.5,4,heuristic,128896,2685664,42,4,128896,1032,55687.3 +csv,unmasked,clustered,0.5,4,all_late,65536,2474528,3,1,65536,1,27188.2 +csv,combined,clustered,0.5,4,all_late,3328,739232,92,1,3328,52,6643.1 +csv,independent,clustered,0.5,4,all_late,128896,2685664,42,4,128896,1032,55409.4 +csv,unmasked,clustered,0.5,4,all_early,65536,2474528,3,1,65536,1,25417.3 +csv,combined,clustered,0.5,4,all_early,3328,739232,92,1,3328,52,6150.2 +csv,independent,clustered,0.5,4,all_early,128896,2685664,42,4,128896,1032,51132.5 +csv,unmasked,clustered,0.5,8,heuristic,65536,6701944,3,1,65536,1,33187.9 +csv,combined,clustered,0.5,8,heuristic,192,92312,27,1,192,3,2555.5 +csv,independent,clustered,0.5,8,heuristic,258368,7133064,112,8,258368,2083,106484.8 +csv,unmasked,clustered,0.5,8,all_late,65536,6701944,3,1,65536,1,36840.1 +csv,combined,clustered,0.5,8,all_late,192,92312,27,1,192,3,3105.9 +csv,independent,clustered,0.5,8,all_late,258368,7133064,112,8,258368,2083,114315.0 +csv,unmasked,clustered,0.5,8,all_early,65536,6701944,3,1,65536,1,33919.9 +csv,combined,clustered,0.5,8,all_early,192,92312,27,1,192,3,4259.5 +csv,independent,clustered,0.5,8,all_early,258368,7133064,112,8,258368,2083,99194.9 +csv,unmasked,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,17438.1 +csv,combined,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,22303.5 +csv,independent,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,23202.6 +csv,unmasked,clustered,1,1,all_late,65536,1175680,1,1,65536,1,17008.5 +csv,combined,clustered,1,1,all_late,65536,1175680,1,1,65536,1,22348.3 +csv,independent,clustered,1,1,all_late,65536,1175680,1,1,65536,1,22428.3 +csv,unmasked,clustered,1,1,all_early,65536,1175680,1,1,65536,1,21278.3 +csv,combined,clustered,1,1,all_early,65536,1175680,1,1,65536,1,23035.9 +csv,independent,clustered,1,1,all_early,65536,1175680,1,1,65536,1,21643.5 +csv,unmasked,clustered,1,2,heuristic,65536,2227328,1,1,65536,1,18154.8 +csv,combined,clustered,1,2,heuristic,65536,2227328,1,1,65536,1,23203.0 +csv,independent,clustered,1,2,heuristic,131072,2350336,3,2,131072,2,43737.0 +csv,unmasked,clustered,1,2,all_late,65536,2227328,1,1,65536,1,19080.1 +csv,combined,clustered,1,2,all_late,65536,2227328,1,1,65536,1,22842.6 +csv,independent,clustered,1,2,all_late,131072,2350336,3,2,131072,2,42759.6 +csv,unmasked,clustered,1,2,all_early,65536,2227328,1,1,65536,1,17399.3 +csv,combined,clustered,1,2,all_early,65536,2227328,1,1,65536,1,22823.0 +csv,independent,clustered,1,2,all_early,131072,2350336,3,2,131072,2,46323.5 +csv,unmasked,clustered,1,4,heuristic,65536,4330624,1,1,65536,1,23527.0 +csv,combined,clustered,1,4,heuristic,65536,4330624,1,1,65536,1,29553.0 +csv,independent,clustered,1,4,heuristic,262144,4699648,7,4,262144,4,96698.4 +csv,unmasked,clustered,1,4,all_late,65536,4330624,1,1,65536,1,22879.7 +csv,combined,clustered,1,4,all_late,65536,4330624,1,1,65536,1,27380.1 +csv,independent,clustered,1,4,all_late,262144,4699648,7,4,262144,4,88048.9 +csv,unmasked,clustered,1,4,all_early,65536,4330624,1,1,65536,1,22879.7 +csv,combined,clustered,1,4,all_early,65536,4330624,1,1,65536,1,28049.7 +csv,independent,clustered,1,4,all_early,262144,4699648,7,4,262144,4,86906.9 +csv,unmasked,clustered,1,8,heuristic,65536,8535168,3,2,65536,1,30948.2 +csv,combined,clustered,1,8,heuristic,65536,8535168,3,2,65536,1,39615.4 +csv,independent,clustered,1,8,heuristic,524288,9398272,15,8,524288,8,183067.9 +csv,unmasked,clustered,1,8,all_late,65536,8535168,3,2,65536,1,29305.8 +csv,combined,clustered,1,8,all_late,65536,8535168,3,2,65536,1,38264.6 +csv,independent,clustered,1,8,all_late,524288,9398272,15,8,524288,8,212102.9 +csv,unmasked,clustered,1,8,all_early,65536,8535168,3,2,65536,1,30725.3 +csv,combined,clustered,1,8,all_early,65536,8535168,3,2,65536,1,35065.9 +csv,independent,clustered,1,8,all_early,524288,9398272,15,8,524288,8,187848.2 +``` diff --git a/.claude/board/entries/README.md b/.claude/board/entries/README.md index 0fc798c6a..fe04ab00a 100644 --- a/.claude/board/entries/README.md +++ b/.claude/board/entries/README.md @@ -25,13 +25,14 @@ index row, (3) no duplicate entry id. Checks 1 and 2 are deliberately opposite directions; the stranding this convention prevents shows up in exactly one of them, never both. -343 entries, 2026-08-06 .. 2026-10-15. +344 entries, 2026-08-06 .. 2026-10-15. | date | entry id | finding | file | |---|---|---|---| | 2026-10-15 | `ledger-correction-wire-contract` | | [2026-10-15-ledger-correction-wire-contract.md](2026-10-15-ledger-correction-wire-contract.md) | | 2026-10-15 | `givens-layer` | | [2026-10-15-givens-layer.md](2026-10-15-givens-layer.md) | | 2026-10-15 | `D-WAL` | `LanceCycleWriter` vs the lancedb 0.40 MemWAL write path (measured) | [2026-10-15-d-wal-shootout.md](2026-10-15-d-wal-shootout.md) | +| 2026-10-15 | `D-HOLO-H14c` | Thought-first reads: tables consulted == requested lanes for any touched count; C vs B mixed; uniform 1 % positional tables ≈ 93× payload resident; Lance scattered masks cut rows, not bytes; stale maps omit silently | [2026-10-15-d-holo-h14c-thought-first.md](2026-10-15-d-holo-h14c-thought-first.md) | | 2026-10-15 | `D-HOLO-H14` | | [2026-10-15-d-holo-h14-lane-storage.md](2026-10-15-d-holo-h14-lane-storage.md) | | 2026-10-14 | `revision-layer-invariants` | | [2026-10-14-revision-layer-invariants.md](2026-10-14-revision-layer-invariants.md) | | 2026-10-14 | `D-MTP-0` | where Hyperon/MeTTa attaches to the masking-algebra polyfill | [2026-10-14-metta-polyfill-map.md](2026-10-14-metta-polyfill-map.md) | diff --git a/.claude/plans/d-holo-h14c-thought-first-v1.md b/.claude/plans/d-holo-h14c-thought-first-v1.md index da0d95f71..9d3600ed5 100644 --- a/.claude/plans/d-holo-h14c-thought-first-v1.md +++ b/.claude/plans/d-holo-h14c-thought-first-v1.md @@ -1,8 +1,8 @@ # D-HOLO-H14c — thought-first positional reads, Hamming presence and Lance 13 masked I/O (v1) -**Status:** PRE-REGISTERED 2026-10-15; nothing measured. Results will be added -as a dated section below; this pre-registration is not edited after the first -run. +**Status:** MEASURED 2026-10-15 (v4). Acceptance A–E met; Lance prediction holds; +C vs B on query-shaped reads mixed (reported). Results in § Results; the +pre-registration above them is unchanged. **D-ids:** D-HOLO-H14c (umbrella), D-HOLO-H14c-1 (point projection and independence), D-HOLO-H14c-2 (presence/Hamming populations), D-HOLO-H14c-3 @@ -42,21 +42,21 @@ instruction operates on them. ## Checklist -- [ ] Pre-registration committed before any benchmark (this file). -- [ ] D-HOLO-H14c-1: typed thought-first read (`Selection` → resolved handles → +- [x] Pre-registration committed before any benchmark (this file). +- [x] D-HOLO-H14c-1: typed thought-first read (`Selection` → resolved handles → `read(i)`), with counters; oracle tests; disable runs. -- [ ] D-HOLO-H14c-2: presence populations through mask-risc programs (AND, OR, +- [x] D-HOLO-H14c-2: presence populations through mask-risc programs (AND, OR, XOR, `Count`); scalar reference; disable runs. -- [ ] D-HOLO-H14c-3: memory and fragmentation measures (lazy, eager, sparse); +- [x] D-HOLO-H14c-3: memory and fragmentation measures (lazy, eager, sparse); perf counters where the kernel allows. -- [ ] D-HOLO-H14c-4: Lance 13 masked I/O probe (combined mask + projection; +- [x] D-HOLO-H14c-4: Lance 13 masked I/O probe (combined mask + projection; independent per-lane masks), with `ExecutionSummaryCounts`. -- [ ] D-HOLO-H14c-5: coordinate identity across append, delete, update, +- [x] D-HOLO-H14c-5: coordinate identity across append, delete, update, reopen, compaction and version change; stale mapping refused. -- [ ] D-HOLO-H14c-6: lane-selection harvest over the repository's existing +- [x] D-HOLO-H14c-6: lane-selection harvest over the repository's existing programs, labelled as test-corpus observation. -- [ ] v4 runs with the tier printed; raw results machine-readable. -- [ ] Results section, board entry, STATUS_BOARD, AGENT_LOG, draft PR. +- [x] v4 runs with the tier printed; raw results machine-readable. +- [x] Results section, board entry, STATUS_BOARD, AGENT_LOG, draft PR. ## 1. Contract: the address is the register @@ -318,3 +318,273 @@ Each run records: the tier the program prints, `rustc --version`, the resolved `lance` version, `MemTotal`, iterations per batch, the command line, and the git sha. Raw results go to `.claude/board/entries/` as a dated machine-readable block (CSV inside the entry) and the console output to the session scratchpad. + + +## Results (v4, 2026-10-15) + +**Run record.** `tier: v4 (avx512f)` printed by both probes (Intel Xeon @ 2.80 GHz, +4 vCPUs, avx512f/bw/cd/dq/vl/vnni; `MemTotal 16,479,424 kB`); `rustc 1.99.0 +(b940084d7 2026-09-28)`; `lance 13.0.0` (probe crate's own lockfile). In-memory +probe: `cargo run --release -p lance-graph-mask-risc --example +holo_thought_first_probe` (sections A, B, C, thought and spatial axes) and +`… -- memory` (memory grid, one child process per cell); 7 batches of 8,192 +reads, median. Lance probe: `cargo run --release --manifest-path +crates/holo-lance-masked-io-probe/Cargo.toml`, median of 5. All tests ran +before any timing (in-memory 11, Lance 5). The hot-path code of the timed run +equals the committed code; between the run and the commit only the memory +grid moved into child processes and one loop was rewritten for clippy. + +**Limitation stated up front.** The VM exposes no hardware performance +counters (`perf stat` reports cycles, cache-misses and dTLB-load-misses as +"not supported"), so cache and TLB behaviour is measured indirectly: hot vs +cold timing (cold = a 128 MiB eviction pass before every batch), minor page +faults, resident size. No cache-miss or TLB-miss count is claimed. + +### Acceptance criteria + +| | criterion | result | +|---|---|---| +| A | operands accessed directly, no row-first discovery | **met** (oracles 1, 2, 5; disable runs "unrelated lane", "shift address", "drop presence test" red) | +| B | touched tables outside the selection do not set point-read work | **met**: tables consulted == k for U = 2, 8, 31 (exact); at k = 2 the read at U = 31 costs 0.90–1.01× the read at U = 2 hot and 0.95–1.16× cold, every density (rule: ≤ 1.25×) | +| C | populations without values | **met**: value loads 0 (counter); AND / XOR / OR + `Count` through mask-risc equal a scalar bit loop | +| D | no row materialization on point and population paths | **met**: row counter 0; the terminal builds exactly the rows asked (disable "row in read" red) | +| E | correct value across temporal change and reorganization | **met** for the checked path: every § 8 scenario returns the requested coordinates or refuses; disable "no version check" turns both identity tests red | + +### Point projection (A) + + +**hot** — ns per point read, U = 31, uniform, one thought, fallback to base; cells are C / B / S + +| dirty | k = 1 | k = 2 | k = 4 | k = 8 | k = 16 | k = 31 | +|---|---|---|---|---|---|---| +| 0 % | 10 / 7 / 8 | 16 / 10 / 15 | 29 / 16 / 27 | 58 / 35 / 56 | 108 / 34 / 104 | 215 / 62 / 202 | +| 0.1 % | 10 / 7 / 17 | 16 / 11 / 29 | 29 / 15 / 57 | 56 / 22 / 110 | 108 / 43 / 236 | 207 / 61 / 434 | +| 1 % | 10 / 9 / 24 | 16 / 12 / 43 | 29 / 17 / 82 | 56 / 29 / 160 | 112 / 50 / 345 | 272 / 130 / 823 | +| 10 % | 10 / 13 / 32 | 16 / 17 / 65 | 28 / 24 / 139 | 50 / 40 / 306 | 101 / 72 / 651 | 206 / 138 / 1531 | +| 50 % | 10 / 13 / 54 | 19 / 18 / 107 | 32 / 43 / 245 | 42 / 49 / 513 | 119 / 122 / 1690 | 339 / 223 / 5220 | +| 100 % | 15 / 21 / 86 | 10 / 18 / 110 | 15 / 28 / 236 | 32 / 43 / 595 | 211 / 120 / 2017 | 475 / 119 / 5518 | + +**cold** — ns per point read, U = 31, uniform, one thought, fallback to base; cells are C / B / S + +| dirty | k = 1 | k = 2 | k = 4 | k = 8 | k = 16 | k = 31 | +|---|---|---|---|---|---|---| +| 0 % | 105 / 106 / 94 | 161 / 120 / 130 | 157 / 149 / 181 | 298 / 212 / 298 | 462 / 321 / 440 | 689 / 471 / 698 | +| 0.1 % | 107 / 103 / 130 | 158 / 125 / 265 | 185 / 158 / 292 | 282 / 214 / 478 | 399 / 326 / 721 | 600 / 419 / 1115 | +| 1 % | 102 / 114 / 156 | 157 / 159 / 263 | 190 / 188 / 355 | 371 / 237 / 534 | 434 / 367 / 1015 | 718 / 498 / 1332 | +| 10 % | 106 / 156 / 249 | 153 / 261 / 310 | 194 / 241 / 411 | 309 / 393 / 716 | 544 / 559 / 1560 | 911 / 887 / 2860 | +| 50 % | 103 / 202 / 233 | 171 / 393 / 509 | 305 / 305 / 736 | 391 / 502 / 1544 | 580 / 715 / 5064 | 1142 / 982 / 7836 | +| 100 % | 54 / 200 / 189 | 73 / 287 / 374 | 131 / 273 / 715 | 224 / 435 / 2091 | 519 / 644 / 5219 | 1264 / 788 / 12994 | + +**Independence (pre-registered rule)** — C at k = 2: ns per read at U = 2 / 8 / 31, and U = 31 ÷ U = 2 + +| dirty | hot | ratio | cold | ratio | +|---|---|---|---|---| +| 0 % | 16.2 / 16.2 / 16.4 | 1.01 | 164.0 / 151.8 / 161.1 | 0.98 | +| 0.1 % | 16.3 / 16.6 / 16.2 | 1.00 | 164.4 / 151.1 / 158.3 | 0.96 | +| 1 % | 16.5 / 16.2 / 16.2 | 0.98 | 165.0 / 154.3 / 157.3 | 0.95 | +| 10 % | 16.0 / 16.0 / 16.2 | 1.01 | 152.2 / 158.4 / 153.5 | 1.01 | +| 50 % | 19.6 / 18.8 / 19.1 | 0.98 | 147.7 / 144.4 / 171.2 | 1.16 | +| 100 % | 10.8 / 10.3 / 9.7 | 0.90 | 66.3 / 72.2 / 72.8 | 1.10 | + + +What remains necessary in C is one presence test per requested lane, in that +lane's own table, plus one load per present value (or one base load per +fallback). Its cost is linear in k and flat in U. + +**C vs B on query-shaped reads (negative result, reported as measured).** +- Hot, at 0–1 % dirty, B is faster for every k (k = 2: C 16 ns, B 10–12; + k = 31: C 207–272 ns, B 61–130). With fallback to base most reads are + misses; B tests one row index for all k lanes, C tests k presence planes. +- Cold, C matches B up to 1 % dirty at k ≤ 4 and is faster from 10 % dirty at + k ≤ 8 (k = 1 at 100 %: C 54 ns, B 200 ns). At k ≥ 16 B is faster in most + cells. +- S (sparse, binary search) is the slowest arm everywhere except the empty + table hot, and grows with density (k = 31, 100 %: 5.5 µs hot). +- Handle resolution, done once per program: 25–279 ns (one allocation per + selection; not on the per-read path). + +### Populations (B) + +`popcount(Pa & Pb & A)` and `popcount(Pa ^ Pb)` run at 0.9–1.2 ns per 64-address +word (≈ 0.015 ns per address), independent of density and of U; one outlier at +0.39 ns. These numbers include allocating the mask-risc scratch on every call. +Session OR over T thoughts: 0.85–0.87 ns per word at T = 1, 4.2–5.1 at T = 8, +19–32 at T = 64. + +### Terminal (C) + +A full 512-byte row (base plus every overlay of the thought, U = 31): 96–105 ns +at ≤ 1 % dirty, 206 ns at 10 %, 613–614 ns at 50–100 %. Not part of A or B. + +### Thought and spatial axes + +- Point reads across T thoughts (k = 2, U = 31; "warm" = the same 8,192 random + (thought, address) pairs repeated, not the main grid's 256-address hot set): + warm 37–40 ns at T = 1, 40–45 ns at T = 8, 55–67 ns at T = 64; cold 153–170 ns + at T = 1, 160–169 ns at T = 8, 192 ns (1 %) and 365 ns (10 %) at T = 64 + (T = 64 at 10 % is 2.4× T = 1). +- Spatial patterns (k = 2, U = 31, 1 % and 10 %): hot C 13–19 ns, B 11–19 ns, + B ≤ C in 7 of 12 hot cells (all six at 1 %, disjoint at 10 %); cold C + 121–191 ns, B 135–251 ns, B ≤ C in 2 of 12 cold cells (disjoint 1 %: 136 vs + 189 ns; contiguous 10 %: 180 vs 191 ns). Disjoint populations give shared count 0 and Hamming + = sum of populations; overlapping give Hamming 614 for 6,592-address planes. + +### Memory and fragmentation (H14c-3) + +| pattern | dirty | T | logical MiB | payload KiB | presence KiB | sparse persist KiB | C-lazy RSS MiB | C-lazy faults | C-lazy seal ns/dirty | C-eager RSS MiB | C-eager seal ns/dirty | S RSS MiB | lazy RSS per table KiB | flag | +|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---| +| uniform | 0.1 % | 1 | 31 | 33 | 248 | 41 | 7.6 | 1933 | 2628 | 31.3 | 10487 | 0.09 | 251 | | +| uniform | 0.1 % | 8 | 248 | 253 | 1984 | 317 | 58.9 | 15063 | 2641 | 250.0 | 11468 | 0.38 | 243 | | +| uniform | 0.1 % | 64 | 1984 | 2034 | 15872 | 2543 | 470.1 | 120326 | 2671 | 1999.7 | 10290 | 2.68 | 243 | | +| uniform | 1 % | 1 | 31 | 318 | 248 | 398 | 29.0 | 7406 | 979 | 31.3 | 1018 | 0.44 | 957 | page-dense waste | +| uniform | 1 % | 8 | 248 | 2538 | 1984 | 3172 | 231.0 | 59128 | 866 | 250.0 | 1213 | 3.16 | 954 | page-dense waste | +| uniform | 1 % | 64 | 1984 | 20333 | 15872 | 25417 | 1849.5 | 473455 | 986 | 1999.7 | 1067 | 25.02 | 955 | page-dense waste | +| uniform | 10 % | 1 | 31 | 3180 | 248 | 3975 | 31.3 | 8005 | 110 | 31.3 | 111 | 3.93 | 1034 | | +| uniform | 10 % | 8 | 248 | 25412 | 1984 | 31766 | 250.1 | 64019 | 120 | 250.1 | 104 | 31.09 | 1033 | | +| uniform | 10 % | 64 | 1984 | 203190 | 15872 | 253987 | 2000.5 | 512118 | 121 | 2000.5 | 117 | 248.23 | 1033 | | +| uniform | 100 % | 1 | 31 | 31744 | 248 | 39680 | 31.4 | 8016 | 20 | 31.4 | 19 | 39.04 | 1036 | | +| uniform | 100 % | 8 | 248 | 253952 | 1984 | 317440 | 250.9 | 64222 | 16 | 250.9 | 16 | 311.98 | 1036 | | +| uniform | 100 % | 64 | 1984 | 2031616 | 15872 | 2539520 | 2007.3 | 513859 | 16 | 2007.3 | 16 | 2495.55 | 1036 | | +| clustered | 0.1 % | 1 | 31 | 27 | 248 | 34 | 0.5 | 126 | 245 | 31.3 | 14931 | 0.08 | 18 | | +| clustered | 0.1 % | 8 | 248 | 230 | 1984 | 288 | 4.1 | 1039 | 316 | 250.0 | 11755 | 0.34 | 17 | | +| clustered | 0.1 % | 64 | 1984 | 1958 | 15872 | 2448 | 33.0 | 8444 | 231 | 1999.7 | 10421 | 2.57 | 17 | | +| clustered | 1 % | 1 | 31 | 299 | 248 | 374 | 1.9 | 475 | 95 | 31.3 | 1141 | 0.41 | 63 | | +| clustered | 1 % | 8 | 248 | 2489 | 1984 | 3111 | 15.0 | 3822 | 74 | 250.0 | 1089 | 3.10 | 62 | | +| clustered | 1 % | 64 | 1984 | 20387 | 15872 | 25484 | 120.3 | 30783 | 85 | 1999.7 | 1054 | 25.08 | 62 | | +| clustered | 10 % | 1 | 31 | 3169 | 248 | 3961 | 13.1 | 3331 | 73 | 31.3 | 140 | 3.92 | 431 | | +| clustered | 10 % | 8 | 248 | 25206 | 1984 | 31508 | 104.0 | 26608 | 50 | 250.1 | 106 | 30.84 | 429 | | +| clustered | 10 % | 64 | 1984 | 202872 | 15872 | 253590 | 831.6 | 212869 | 53 | 2000.4 | 108 | 247.86 | 429 | | +| clustered | 100 % | 1 | 31 | 31744 | 248 | 39680 | 31.4 | 8016 | 19 | 31.4 | 15 | 39.04 | 1036 | | +| clustered | 100 % | 8 | 248 | 253952 | 1984 | 317440 | 250.9 | 64222 | 17 | 250.9 | 16 | 311.98 | 1036 | | +| clustered | 100 % | 64 | 1984 | 2031616 | 15872 | 2539520 | 2007.3 | 513859 | 15 | 2007.3 | 17 | 2495.55 | 1036 | | + +Flag rule (pre-registered): C-lazy resident ≥ 50 % of 1 MiB per table while +payload < 10 % of 1 MiB. Flagged: **uniform 1 % at every T** (≈ 955 KiB +resident for ≈ 10 KiB of values per table, ≈ 93×). Uniform 10 % is resident +at 1 MiB per table too, but its payload (≈ 102 KiB) sits at the 10 % line. + +- Resident size follows pages touched, not values: a 1 MiB table holds 256 + pages of 256 values; uniform scatter touches nearly every page from about + 1 % dirty, clustered runs do not (62 KiB per table at 1 %). +- C-eager commits the full logical size at every density (≈ 2 GiB at T = 64). +- S holds only the dirty values and addresses: 25 MiB vs 1,850 MiB (C-lazy) at + uniform 1 %, T = 64; its price is the binary search in § Point projection. +- Seal per dirty value (C-lazy) is page-fault bound at low density: 2.6 µs at + uniform 0.1 %, 0.9–1.0 µs at 1 %, 0.11–0.12 µs at 10 %, 16–20 ns at 100 %. +- Reserved virtual memory equals the logical size for every arm that maps the + tables (the virtual-delta column in the raw data). + +### Lance 13 masked I/O (H14c-4) + +Heuristic materialization; the style changed `bytes_read` in **0 of 120 cells**. +Lance's scan statistics expose `bytes_read`, `iops`, `requests` and the counts +`rows_scanned`, `ranges_scanned`, `fragments_scanned`; bytes decoded, pages +accessed and allocations are not exposed and are not claimed. `bytes_read` is +what Lance requested from the local object store (served from the page +cache), not a physical disk count. + +| pattern | dirty | k | style | unmasked bytes | independent bytes (ratio) | rows scanned indep / unmasked | combined rows | combined bytes (ratio) | unmasked µs | combined µs | independent µs | +|---|---|---|---|---|---|---|---|---|---|---|---| +| uniform | 0.1 % | 1 | heuristic | 127296 | 97424 (0.77) | 46 / 65536 | 46 | 97424 (0.77) | 20361 | 1903 | 1732 | +| uniform | 0.1 % | 2 | heuristic | 131560 | 202952 (1.54) | 112 / 65536 | 1 | 6536 (0.05) | 19577 | 1441 | 3531 | +| uniform | 0.1 % | 4 | heuristic | 140808 | 419424 (2.98) | 245 / 65536 | 0 | 0 (0.00) | 44787 | 459 | 6882 | +| uniform | 0.1 % | 8 | heuristic | 159736 | 849024 (5.32) | 531 / 65536 | 0 | 0 (0.00) | 50480 | 690 | 14724 | +| uniform | 1 % | 1 | heuristic | 136160 | 136160 (1.00) | 692 / 65536 | 692 | 136160 (1.00) | 17419 | 2238 | 2059 | +| uniform | 1 % | 2 | heuristic | 147720 | 271752 (1.84) | 1354 / 65536 | 9 | 30920 (0.21) | 18436 | 2420 | 7810 | +| uniform | 1 % | 4 | heuristic | 170624 | 542720 (3.18) | 2655 / 65536 | 0 | 0 (0.00) | 28349 | 588 | 11766 | +| uniform | 1 % | 8 | heuristic | 217040 | 1085264 (5.00) | 5304 / 65536 | 0 | 0 (0.00) | 43980 | 579 | 23244 | +| uniform | 10 % | 1 | heuristic | 195416 | 195416 (1.00) | 6606 / 65536 | 6606 | 195416 (1.00) | 22045 | 6994 | 7035 | +| uniform | 10 % | 2 | heuristic | 266584 | 390616 (1.47) | 13194 / 65536 | 679 | 266584 (1.00) | 21164 | 3198 | 14780 | +| uniform | 10 % | 4 | heuristic | 409560 | 781656 (1.91) | 26435 / 65536 | 8 | 143320 (0.35) | 26194 | 2735 | 28000 | +| uniform | 10 % | 8 | heuristic | 692016 | 1560240 (2.25) | 52513 / 65536 | 0 | 0 (0.00) | 50365 | 529 | 64182 | +| uniform | 50 % | 1 | heuristic | 1208448 | 1208448 (1.00) | 33120 / 65536 | 33120 | 1208448 (1.00) | 18861 | 20882 | 22606 | +| uniform | 50 % | 2 | heuristic | 2292864 | 2415872 (1.05) | 65891 / 65536 | 16591 | 2292864 (1.00) | 21271 | 18150 | 43608 | +| uniform | 50 % | 4 | heuristic | 2541824 | 2912640 (1.15) | 131294 / 65536 | 4074 | 2541824 (1.00) | 29479 | 11880 | 79249 | +| uniform | 50 % | 8 | heuristic | 4958336 | 5824256 (1.17) | 261893 / 65536 | 247 | 3195520 (0.64) | 39020 | 11242 | 167085 | +| uniform | 100 % | 1 | heuristic | 1175680 | 1175680 (1.00) | 65536 / 65536 | 65536 | 1175680 (1.00) | 17436 | 21706 | 21129 | +| uniform | 100 % | 2 | heuristic | 2227328 | 2350336 (1.06) | 131072 / 65536 | 65536 | 2227328 (1.00) | 20555 | 30819 | 44391 | +| uniform | 100 % | 4 | heuristic | 4330624 | 4699648 (1.09) | 262144 / 65536 | 65536 | 4330624 (1.00) | 22931 | 27403 | 87673 | +| uniform | 100 % | 8 | heuristic | 8535168 | 9398272 (1.10) | 524288 / 65536 | 65536 | 8535168 (1.00) | 33334 | 38369 | 192390 | +| clustered | 0.1 % | 1 | heuristic | 127744 | 3000 (0.02) | 64 / 65536 | 64 | 3000 (0.02) | 17289 | 1350 | 1394 | +| clustered | 0.1 % | 2 | heuristic | 132552 | 6008 (0.05) | 128 / 65536 | 0 | 0 (0.00) | 18579 | 349 | 2546 | +| clustered | 0.1 % | 4 | heuristic | 143048 | 14184 (0.10) | 320 / 65536 | 0 | 0 (0.00) | 21828 | 440 | 4593 | +| clustered | 0.1 % | 8 | heuristic | 153648 | 28664 (0.19) | 640 / 65536 | 0 | 0 (0.00) | 28765 | 546 | 10190 | +| clustered | 1 % | 1 | heuristic | 130448 | 31504 (0.24) | 704 / 65536 | 704 | 31504 (0.24) | 16859 | 1812 | 1488 | +| clustered | 1 % | 2 | heuristic | 135832 | 50136 (0.37) | 1216 / 65536 | 0 | 0 (0.00) | 18830 | 343 | 2957 | +| clustered | 1 % | 4 | heuristic | 145968 | 91200 (0.62) | 2112 / 65536 | 0 | 0 (0.00) | 31447 | 412 | 6281 | +| clustered | 1 % | 8 | heuristic | 169416 | 214248 (1.26) | 4544 / 65536 | 0 | 0 (0.00) | 28629 | 498 | 14205 | +| clustered | 10 % | 1 | heuristic | 159928 | 153736 (0.96) | 6528 / 65536 | 6528 | 153736 (0.96) | 17550 | 3528 | 3605 | +| clustered | 10 % | 2 | heuristic | 194472 | 308184 (1.58) | 12800 / 65536 | 832 | 80512 (0.41) | 18680 | 1934 | 6508 | +| clustered | 10 % | 4 | heuristic | 263544 | 619256 (2.35) | 25344 / 65536 | 0 | 0 (0.00) | 23435 | 425 | 13853 | +| clustered | 10 % | 8 | heuristic | 406864 | 1250448 (3.07) | 51456 / 65536 | 0 | 0 (0.00) | 29721 | 532 | 31067 | +| clustered | 50 % | 1 | heuristic | 1180776 | 1086016 (0.92) | 32512 / 65536 | 32512 | 1086016 (0.92) | 17714 | 13810 | 14064 | +| clustered | 50 % | 2 | heuristic | 1299824 | 1328816 (1.02) | 64640 / 65536 | 15232 | 915328 (0.70) | 21886 | 10748 | 27227 | +| clustered | 50 % | 4 | heuristic | 2474528 | 2685664 (1.09) | 128896 / 65536 | 3328 | 739232 (0.30) | 25104 | 6432 | 55687 | +| clustered | 50 % | 8 | heuristic | 6701944 | 7133064 (1.06) | 258368 / 65536 | 192 | 92312 (0.01) | 33188 | 2556 | 106485 | +| clustered | 100 % | 1 | heuristic | 1175680 | 1175680 (1.00) | 65536 / 65536 | 65536 | 1175680 (1.00) | 17438 | 22304 | 23203 | +| clustered | 100 % | 2 | heuristic | 2227328 | 2350336 (1.06) | 131072 / 65536 | 65536 | 2227328 (1.00) | 18155 | 23203 | 43737 | +| clustered | 100 % | 4 | heuristic | 4330624 | 4699648 (1.09) | 262144 / 65536 | 65536 | 4330624 (1.00) | 23527 | 29553 | 96698 | +| clustered | 100 % | 8 | heuristic | 8535168 | 9398272 (1.10) | 524288 / 65536 | 65536 | 8535168 (1.00) | 30948 | 39615 | 183068 | + +**Prediction: both halves hold.** At 1 % uniform, k = 1: masked bytes = unmasked +bytes (136,160; ratio 1.00) while rows scanned fall to 692 of 65,536. At 1 % +clustered, k = 1: ratio 0.24 (≤ 0.5). At 0.1 % uniform the ratio is 0.77. + +- A scattered mask cuts rows decoded, not bytes fetched; a clustered mask cuts + both. Lance reads in pages, so the mask helps exactly when presence is + page-local. +- Independent per-lane masked reads (one scan per lane, each re-reading + `coord`) fetch more bytes than one unmasked projection whenever k ≥ 2 at + uniform low density (1.5–5.3×). +- The combined mask (every requested lane present) is the joint population, + ≈ dᵏ for independent lanes: one row at 0.1 %, k = 2. +- Wall time: masked reads of small populations take 0.3–2.4 ms against + 17–55 ms unmasked; at 100 % the masked read is slower (22 vs 17 ms, k = 1). + +### Coordinate identity (H14c-5) + +The checked read refused every stale map. Without the check, a stale map +returned (k = 1, 241 requested coordinates): + +| rewrite | stable row ids | returned | wrong coord | silently missing | +|---|---|---|---|---| +| overwrite, reversed | off | 0 | 0 | 241 | +| delete + compaction | off | 0 | 0 | 160 of 160 live | +| update (epoch) | off | 123 | 0 | 118 | +| overwrite, reversed | on | 0 | 0 | 241 | +| delete + compaction | on | 160 | 0 | 0 | +| update (epoch) | on | 241 | 0 | 0 | + +- The hazard observed is **silent omission**, not a wrong coordinate; a wrong + coordinate is also excluded structurally because values are attributed by + the stored `coord`, never by output position (oracle 9). +- Without stable row ids, compaction changed 3,510 of 3,510 `_rowid`s and an + update moved 85 of 85 updated rows; with stable row ids, 0 and 0. An + overwrite breaks the mapping either way. +- `VersionClock` (#1567) already states that a reordering rewrite needs a new + clock; the same boundary holds for row identity. + +### Workload harvest (H14c-6) — test-corpus observation, not workload + +`lane_footprint(&Program)` reads the planes and lanes a program names. A +read-only census (Haiku, spot-checked) of the 169 `Program::new` constructions +in mask-risc tests and `lance-graph-quack`: 61 countable literally, 108 built +dynamically. Distinct value lanes per literal program: 0 → 26, 1 → 31, 2 → 4. +No corpus of executed thought programs exists; no workload frequency is +claimed. + +### What this answers + +Given thought, operands and address, the operations still necessary are: one +presence test per requested lane (in that lane's table), one load per present +value or base fallback, and, for populations, one word operation per 64 +addresses per plane. Row assembly, trie or rank traversal, and row-first lane +discovery disappear; the touched tables outside the selection cost nothing. +The cost that remains open is physical: dense positional tables are resident at +about one page per touched page of addresses, which at uniform 1 % is ≈ 93× the +payload, and Lance fetches whole pages for scattered masks. + +**OPEN (returned to the operator, no layout decided):** how to bound the +resident cost of positional tables without reintroducing traversal; whether to +enable stable row ids for lane datasets; whether lane data that is read by +scattered masks should be laid out so presence is page-local. From a79050ac5a10776dbb99f5d2ee3730f9f61f1f9f Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 23:56:22 +0000 Subject: [PATCH 8/9] D-HOLO H14c: build per-lane masks before the timer; print the resolved lance version Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- crates/holo-lance-masked-io-probe/build.rs | 27 +++++++++++++++++++ crates/holo-lance-masked-io-probe/src/main.rs | 27 ++++++++++++------- 2 files changed, 45 insertions(+), 9 deletions(-) create mode 100644 crates/holo-lance-masked-io-probe/build.rs diff --git a/crates/holo-lance-masked-io-probe/build.rs b/crates/holo-lance-masked-io-probe/build.rs new file mode 100644 index 000000000..14630b0ee --- /dev/null +++ b/crates/holo-lance-masked-io-probe/build.rs @@ -0,0 +1,27 @@ +//! Records the `lance` version this build resolved, so the probe prints what +//! it was built against. The repository tracks no `Cargo.lock`; cargo writes +//! one next to this excluded crate's manifest before running this script. + +use std::path::Path; + +fn main() { + let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap(); + let lock = Path::new(&dir).join("Cargo.lock"); + println!("cargo:rerun-if-changed={}", lock.display()); + let text = std::fs::read_to_string(&lock).unwrap_or_default(); + let mut version = "unknown".to_string(); + let mut in_lance = false; + for line in text.lines() { + if line == "[[package]]" { + in_lance = false; + } else if line == "name = \"lance\"" { + in_lance = true; + } else if in_lance { + if let Some(v) = line.strip_prefix("version = \"") { + version = v.trim_end_matches('"').to_string(); + break; + } + } + } + println!("cargo:rustc-env=PROBE_LANCE_VERSION={version}"); +} diff --git a/crates/holo-lance-masked-io-probe/src/main.rs b/crates/holo-lance-masked-io-probe/src/main.rs index 6fce2b906..260ee3e8a 100644 --- a/crates/holo-lance-masked-io-probe/src/main.rs +++ b/crates/holo-lance-masked-io-probe/src/main.rs @@ -307,7 +307,10 @@ fn median(mut v: Vec) -> f64 { #[tokio::main(flavor = "multi_thread", worker_threads = 4)] async fn main() { - println!("lance: 13.0.0 (resolved; see Cargo.lock of this probe crate)"); + println!( + "lance: {} (resolved at build time; no lockfile is tracked)", + env!("PROBE_LANCE_VERSION") + ); println!( "tier: {}", if cfg!(target_feature = "avx512f") { @@ -369,19 +372,25 @@ async fn main() { io = i; } report("combined", p, d, k, &style, &io, median(walls)); - // independent: each lane with its own mask, aligned by coord + // independent: each lane with its own mask, aligned by coord. + // The masks are built before the timer, as `joint` is above. + let owns: Vec> = lanes + .iter() + .map(|&l| { + coords + .iter() + .copied() + .filter(|&c| present(p, d, l, c)) + .collect() + }) + .collect(); let mut walls = Vec::new(); let mut sum = Io::default(); for _ in 0..5 { sum = Io::default(); let t = Instant::now(); - for &l in &lanes { - let own: Vec = coords - .iter() - .copied() - .filter(|&c| present(p, d, l, c)) - .collect(); - let (_, i) = masked_read(&ds, &map, &own, &[l], style.clone(), true) + for (&l, own) in lanes.iter().zip(&owns) { + let (_, i) = masked_read(&ds, &map, own, &[l], style.clone(), true) .await .unwrap(); sum.bytes_read += i.bytes_read; From da3f206721694dc86d4e4b350bc7e5974a4323bb Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 15 Oct 2026 23:59:26 +0000 Subject: [PATCH 9/9] D-HOLO H14c: Lance timings from the re-run; version provenance corrected The first run timed per-lane mask construction inside the independent strategy's loop. Re-run with masks built before the timer: all 360 rows match the first run on bytes, IOPS, requests and rows scanned; the three timing columns now come from the re-run and the wall-time bullet is re-derived from it. The lance version is printed from the build, not from an untracked lockfile. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011BMJnDBAfzcuQh5HeT39Rh --- .../2026-10-15-d-holo-h14c-thought-first.md | 727 +++++++++--------- .claude/plans/d-holo-h14c-thought-first-v1.md | 97 +-- 2 files changed, 419 insertions(+), 405 deletions(-) diff --git a/.claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md b/.claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md index 32035c82d..a5120a01c 100644 --- a/.claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md +++ b/.claude/board/entries/2026-10-15-d-holo-h14c-thought-first.md @@ -1,7 +1,7 @@ # D-HOLO-H14c — thought-first positional reads, Hamming presence, Lance 13 masked I/O (v4, 2026-10-15) **Status:** MEASURED. Plan: `.claude/plans/d-holo-h14c-thought-first-v1.md` (pre-registered before the run; results there). -**Probes:** `crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs`; `crates/holo-lance-masked-io-probe` (excluded from the workspace). `tier: v4 (avx512f)`, rustc 1.99.0, lance 13.0.0. +**Probes:** `crates/lance-graph-mask-risc/examples/holo_thought_first_probe.rs`; `crates/holo-lance-masked-io-probe` (excluded from the workspace). `tier: v4 (avx512f)`, rustc 1.99.0, lance 13.0.0 (resolved at build time and printed by the probe; no lockfile is tracked). - Acceptance A–E met: a read consults exactly the requested lane tables (counter == k for U = 2, 8, 31); at k = 2 the read at U = 31 costs @@ -31,7 +31,10 @@ Columns, in-memory probe: `csv,section,arm,pattern,density,T,U,k,cache,metric,va (section A point, B population, C terminal, M memory). Lance probe: `csv,strategy,pattern,density,k,style,rows_emitted,bytes_read,iops,requests,rows_scanned,ranges_scanned,wall_us`. Memory rows come from the per-cell child-process run; the first run's memory -rows were discarded (allocator reuse zeroed their deltas). +rows were discarded (allocator reuse zeroed their deltas). The Lance rows +come from the re-run after review: the first run built the independent +strategy's per-lane masks inside the timed loop. Both runs agree on every +byte and row count; only `wall_us` differs. ```csv csv,section,arm,pattern,density,T,U,k,cache,metric,value @@ -1209,364 +1212,364 @@ csv,M,S,clustered,1,64,31,0,-,seal_ns_per_dirty,25.714 ```csv csv,strategy,pattern,density,k,style,rows_emitted,bytes_read,iops,requests,rows_scanned,ranges_scanned,wall_us -csv,unmasked,uniform,0.001,1,heuristic,65536,127296,1,1,65536,1,20360.7 -csv,combined,uniform,0.001,1,heuristic,46,97424,6,1,46,46,1902.8 -csv,independent,uniform,0.001,1,heuristic,46,97424,6,1,46,46,1731.5 -csv,unmasked,uniform,0.001,1,all_late,65536,127296,1,1,65536,1,17898.6 -csv,combined,uniform,0.001,1,all_late,46,97424,6,1,46,46,2204.8 -csv,independent,uniform,0.001,1,all_late,46,97424,6,1,46,46,1895.5 -csv,unmasked,uniform,0.001,1,all_early,65536,127296,1,1,65536,1,18245.1 -csv,combined,uniform,0.001,1,all_early,46,97424,6,1,46,46,1786.5 -csv,independent,uniform,0.001,1,all_early,46,97424,6,1,46,46,1694.8 -csv,unmasked,uniform,0.001,2,heuristic,65536,131560,1,1,65536,1,19577.3 -csv,combined,uniform,0.001,2,heuristic,1,6536,2,1,1,1,1441.1 -csv,independent,uniform,0.001,2,heuristic,112,202952,11,2,112,112,3531.2 -csv,unmasked,uniform,0.001,2,all_late,65536,131560,1,1,65536,1,21931.8 -csv,combined,uniform,0.001,2,all_late,1,6536,2,1,1,1,1391.8 -csv,independent,uniform,0.001,2,all_late,112,202952,11,2,112,112,3962.0 -csv,unmasked,uniform,0.001,2,all_early,65536,131560,1,1,65536,1,21526.9 -csv,combined,uniform,0.001,2,all_early,1,6536,2,1,1,1,1404.4 -csv,independent,uniform,0.001,2,all_early,112,202952,11,2,112,112,3962.1 -csv,unmasked,uniform,0.001,4,heuristic,65536,140808,1,1,65536,1,44787.4 -csv,combined,uniform,0.001,4,heuristic,0,0,0,0,0,0,458.9 -csv,independent,uniform,0.001,4,heuristic,245,419424,23,4,245,245,6882.4 -csv,unmasked,uniform,0.001,4,all_late,65536,140808,1,1,65536,1,32817.0 -csv,combined,uniform,0.001,4,all_late,0,0,0,0,0,0,437.1 -csv,independent,uniform,0.001,4,all_late,245,419424,23,4,245,245,7015.5 -csv,unmasked,uniform,0.001,4,all_early,65536,140808,1,1,65536,1,35108.5 -csv,combined,uniform,0.001,4,all_early,0,0,0,0,0,0,417.8 -csv,independent,uniform,0.001,4,all_early,245,419424,23,4,245,245,7220.3 -csv,unmasked,uniform,0.001,8,heuristic,65536,159736,1,1,65536,1,50479.8 -csv,combined,uniform,0.001,8,heuristic,0,0,0,0,0,0,689.6 -csv,independent,uniform,0.001,8,heuristic,531,849024,42,8,531,530,14723.7 -csv,unmasked,uniform,0.001,8,all_late,65536,159736,1,1,65536,1,55928.1 -csv,combined,uniform,0.001,8,all_late,0,0,0,0,0,0,534.7 -csv,independent,uniform,0.001,8,all_late,531,849024,42,8,531,530,12213.7 -csv,unmasked,uniform,0.001,8,all_early,65536,159736,1,1,65536,1,45996.3 -csv,combined,uniform,0.001,8,all_early,0,0,0,0,0,0,807.1 -csv,independent,uniform,0.001,8,all_early,531,849024,42,8,531,530,15941.2 -csv,unmasked,uniform,0.01,1,heuristic,65536,136160,1,1,65536,1,17418.8 -csv,combined,uniform,0.01,1,heuristic,692,136160,1,1,692,689,2237.7 -csv,independent,uniform,0.01,1,heuristic,692,136160,1,1,692,689,2059.0 -csv,unmasked,uniform,0.01,1,all_late,65536,136160,1,1,65536,1,16628.3 -csv,combined,uniform,0.01,1,all_late,692,136160,1,1,692,689,3109.5 -csv,independent,uniform,0.01,1,all_late,692,136160,1,1,692,689,2976.2 -csv,unmasked,uniform,0.01,1,all_early,65536,136160,1,1,65536,1,20721.0 -csv,combined,uniform,0.01,1,all_early,692,136160,1,1,692,689,2864.6 -csv,independent,uniform,0.01,1,all_early,692,136160,1,1,692,689,2694.1 -csv,unmasked,uniform,0.01,2,heuristic,65536,147720,2,1,65536,1,18435.6 -csv,combined,uniform,0.01,2,heuristic,9,30920,10,1,9,9,2419.7 -csv,independent,uniform,0.01,2,heuristic,1354,271752,3,2,1354,1341,7810.5 -csv,unmasked,uniform,0.01,2,all_late,65536,147720,2,1,65536,1,22980.0 -csv,combined,uniform,0.01,2,all_late,9,30920,10,1,9,9,1755.1 -csv,independent,uniform,0.01,2,all_late,1354,271752,3,2,1354,1341,5014.4 -csv,unmasked,uniform,0.01,2,all_early,65536,147720,2,1,65536,1,24046.7 -csv,combined,uniform,0.01,2,all_early,9,30920,10,1,9,9,1828.5 -csv,independent,uniform,0.01,2,all_early,1354,271752,3,2,1354,1341,4873.7 -csv,unmasked,uniform,0.01,4,heuristic,65536,170624,4,1,65536,1,28349.1 -csv,combined,uniform,0.01,4,heuristic,0,0,0,0,0,0,587.8 -csv,independent,uniform,0.01,4,heuristic,2655,542720,7,4,2655,2635,11765.9 -csv,unmasked,uniform,0.01,4,all_late,65536,170624,4,1,65536,1,23478.2 -csv,combined,uniform,0.01,4,all_late,0,0,0,0,0,0,436.3 -csv,independent,uniform,0.01,4,all_late,2655,542720,7,4,2655,2635,11137.5 -csv,unmasked,uniform,0.01,4,all_early,65536,170624,4,1,65536,1,24283.6 -csv,combined,uniform,0.01,4,all_early,0,0,0,0,0,0,401.9 -csv,independent,uniform,0.01,4,all_early,2655,542720,7,4,2655,2635,9056.0 -csv,unmasked,uniform,0.01,8,heuristic,65536,217040,8,1,65536,1,43979.9 -csv,combined,uniform,0.01,8,heuristic,0,0,0,0,0,0,579.0 -csv,independent,uniform,0.01,8,heuristic,5304,1085264,15,8,5304,5266,23243.7 -csv,unmasked,uniform,0.01,8,all_late,65536,217040,8,1,65536,1,52073.5 -csv,combined,uniform,0.01,8,all_late,0,0,0,0,0,0,617.8 -csv,independent,uniform,0.01,8,all_late,5304,1085264,15,8,5304,5266,18135.3 -csv,unmasked,uniform,0.01,8,all_early,65536,217040,8,1,65536,1,43520.5 -csv,combined,uniform,0.01,8,all_early,0,0,0,0,0,0,546.6 -csv,independent,uniform,0.01,8,all_early,5304,1085264,15,8,5304,5266,24799.9 -csv,unmasked,uniform,0.1,1,heuristic,65536,195416,1,1,65536,1,22045.2 -csv,combined,uniform,0.1,1,heuristic,6606,195416,1,1,6606,5937,6994.0 -csv,independent,uniform,0.1,1,heuristic,6606,195416,1,1,6606,5937,7034.8 -csv,unmasked,uniform,0.1,1,all_late,65536,195416,1,1,65536,1,17042.9 -csv,combined,uniform,0.1,1,all_late,6606,195416,1,1,6606,5937,7443.2 -csv,independent,uniform,0.1,1,all_late,6606,195416,1,1,6606,5937,8357.6 -csv,unmasked,uniform,0.1,1,all_early,65536,195416,1,1,65536,1,20993.0 -csv,combined,uniform,0.1,1,all_early,6606,195416,1,1,6606,5937,8500.6 -csv,independent,uniform,0.1,1,all_early,6606,195416,1,1,6606,5937,8234.3 -csv,unmasked,uniform,0.1,2,heuristic,65536,266584,2,1,65536,1,21163.7 -csv,combined,uniform,0.1,2,heuristic,679,266584,2,1,679,672,3197.9 -csv,independent,uniform,0.1,2,heuristic,13194,390616,3,2,13194,11864,14780.0 -csv,unmasked,uniform,0.1,2,all_late,65536,266584,2,1,65536,1,19575.8 -csv,combined,uniform,0.1,2,all_late,679,266584,2,1,679,672,3174.1 -csv,independent,uniform,0.1,2,all_late,13194,390616,3,2,13194,11864,16857.3 -csv,unmasked,uniform,0.1,2,all_early,65536,266584,2,1,65536,1,21175.7 -csv,combined,uniform,0.1,2,all_early,679,266584,2,1,679,672,3291.7 -csv,independent,uniform,0.1,2,all_early,13194,390616,3,2,13194,11864,14129.9 -csv,unmasked,uniform,0.1,4,heuristic,65536,409560,4,1,65536,1,26193.7 -csv,combined,uniform,0.1,4,heuristic,8,143320,18,1,8,8,2734.8 -csv,independent,uniform,0.1,4,heuristic,26435,781656,7,4,26435,23772,28000.3 -csv,unmasked,uniform,0.1,4,all_late,65536,409560,4,1,65536,1,24184.1 -csv,combined,uniform,0.1,4,all_late,8,143320,18,1,8,8,2501.0 -csv,independent,uniform,0.1,4,all_late,26435,781656,7,4,26435,23772,29428.7 -csv,unmasked,uniform,0.1,4,all_early,65536,409560,4,1,65536,1,24306.0 -csv,combined,uniform,0.1,4,all_early,8,143320,18,1,8,8,2528.9 -csv,independent,uniform,0.1,4,all_early,26435,781656,7,4,26435,23772,33150.1 -csv,unmasked,uniform,0.1,8,heuristic,65536,692016,8,1,65536,1,50364.8 -csv,combined,uniform,0.1,8,heuristic,0,0,0,0,0,0,528.9 -csv,independent,uniform,0.1,8,heuristic,52513,1560240,15,8,52513,47298,64182.2 -csv,unmasked,uniform,0.1,8,all_late,65536,692016,8,1,65536,1,46960.8 -csv,combined,uniform,0.1,8,all_late,0,0,0,0,0,0,497.5 -csv,independent,uniform,0.1,8,all_late,52513,1560240,15,8,52513,47298,61958.8 -csv,unmasked,uniform,0.1,8,all_early,65536,692016,8,1,65536,1,44671.3 -csv,combined,uniform,0.1,8,all_early,0,0,0,0,0,0,670.2 -csv,independent,uniform,0.1,8,all_early,52513,1560240,15,8,52513,47298,59927.2 -csv,unmasked,uniform,0.5,1,heuristic,65536,1208448,1,1,65536,1,18860.6 -csv,combined,uniform,0.5,1,heuristic,33120,1208448,1,1,33120,16289,20881.7 -csv,independent,uniform,0.5,1,heuristic,33120,1208448,1,1,33120,16289,22606.5 -csv,unmasked,uniform,0.5,1,all_late,65536,1208448,1,1,65536,1,19585.1 -csv,combined,uniform,0.5,1,all_late,33120,1208448,1,1,33120,16289,18725.9 -csv,independent,uniform,0.5,1,all_late,33120,1208448,1,1,33120,16289,21411.1 -csv,unmasked,uniform,0.5,1,all_early,65536,1208448,1,1,65536,1,17377.9 -csv,combined,uniform,0.5,1,all_early,33120,1208448,1,1,33120,16289,19883.6 -csv,independent,uniform,0.5,1,all_early,33120,1208448,1,1,33120,16289,19130.6 -csv,unmasked,uniform,0.5,2,heuristic,65536,2292864,1,1,65536,1,21271.1 -csv,combined,uniform,0.5,2,heuristic,16591,2292864,1,1,16591,12357,18149.8 -csv,independent,uniform,0.5,2,heuristic,65891,2415872,3,2,65891,32770,43607.9 -csv,unmasked,uniform,0.5,2,all_late,65536,2292864,1,1,65536,1,22177.3 -csv,combined,uniform,0.5,2,all_late,16591,2292864,1,1,16591,12357,20511.2 -csv,independent,uniform,0.5,2,all_late,65891,2415872,3,2,65891,32770,41180.7 -csv,unmasked,uniform,0.5,2,all_early,65536,2292864,1,1,65536,1,22188.9 -csv,combined,uniform,0.5,2,all_early,16591,2292864,1,1,16591,12357,15729.0 -csv,independent,uniform,0.5,2,all_early,65891,2415872,3,2,65891,32770,39933.7 -csv,unmasked,uniform,0.5,4,heuristic,65536,2541824,2,1,65536,1,29479.1 -csv,combined,uniform,0.5,4,heuristic,4074,2541824,2,1,4074,3809,11879.6 -csv,independent,uniform,0.5,4,heuristic,131294,2912640,7,4,131294,65436,79249.0 -csv,unmasked,uniform,0.5,4,all_late,65536,2541824,2,1,65536,1,30822.9 -csv,combined,uniform,0.5,4,all_late,4074,2541824,2,1,4074,3809,12342.1 -csv,independent,uniform,0.5,4,all_late,131294,2912640,7,4,131294,65436,78326.7 -csv,unmasked,uniform,0.5,4,all_early,65536,2541824,2,1,65536,1,25393.9 -csv,combined,uniform,0.5,4,all_early,4074,2541824,2,1,4074,3809,11960.8 -csv,independent,uniform,0.5,4,all_early,131294,2912640,7,4,131294,65436,74817.5 -csv,unmasked,uniform,0.5,8,heuristic,65536,4958336,5,1,65536,1,39019.6 -csv,combined,uniform,0.5,8,heuristic,247,3195520,272,1,247,246,11241.5 -csv,independent,uniform,0.5,8,heuristic,261893,5824256,15,8,261893,131042,167084.9 -csv,unmasked,uniform,0.5,8,all_late,65536,4958336,5,1,65536,1,41161.9 -csv,combined,uniform,0.5,8,all_late,247,3195520,272,1,247,246,12822.9 -csv,independent,uniform,0.5,8,all_late,261893,5824256,15,8,261893,131042,179208.7 -csv,unmasked,uniform,0.5,8,all_early,65536,4958336,5,1,65536,1,35608.5 -csv,combined,uniform,0.5,8,all_early,247,3195520,272,1,247,246,11137.6 -csv,independent,uniform,0.5,8,all_early,261893,5824256,15,8,261893,131042,171670.5 -csv,unmasked,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,17435.7 -csv,combined,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,21705.7 -csv,independent,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,21128.8 -csv,unmasked,uniform,1,1,all_late,65536,1175680,1,1,65536,1,15722.4 -csv,combined,uniform,1,1,all_late,65536,1175680,1,1,65536,1,20612.1 -csv,independent,uniform,1,1,all_late,65536,1175680,1,1,65536,1,20793.1 -csv,unmasked,uniform,1,1,all_early,65536,1175680,1,1,65536,1,20284.3 -csv,combined,uniform,1,1,all_early,65536,1175680,1,1,65536,1,23424.4 -csv,independent,uniform,1,1,all_early,65536,1175680,1,1,65536,1,22368.9 -csv,unmasked,uniform,1,2,heuristic,65536,2227328,1,1,65536,1,20554.8 -csv,combined,uniform,1,2,heuristic,65536,2227328,1,1,65536,1,30818.6 -csv,independent,uniform,1,2,heuristic,131072,2350336,3,2,131072,2,44391.0 -csv,unmasked,uniform,1,2,all_late,65536,2227328,1,1,65536,1,19361.0 -csv,combined,uniform,1,2,all_late,65536,2227328,1,1,65536,1,24504.7 -csv,independent,uniform,1,2,all_late,131072,2350336,3,2,131072,2,43616.7 -csv,unmasked,uniform,1,2,all_early,65536,2227328,1,1,65536,1,19477.3 -csv,combined,uniform,1,2,all_early,65536,2227328,1,1,65536,1,23519.7 -csv,independent,uniform,1,2,all_early,131072,2350336,3,2,131072,2,43864.3 -csv,unmasked,uniform,1,4,heuristic,65536,4330624,1,1,65536,1,22930.6 -csv,combined,uniform,1,4,heuristic,65536,4330624,1,1,65536,1,27403.2 -csv,independent,uniform,1,4,heuristic,262144,4699648,7,4,262144,4,87672.9 -csv,unmasked,uniform,1,4,all_late,65536,4330624,1,1,65536,1,23857.0 -csv,combined,uniform,1,4,all_late,65536,4330624,1,1,65536,1,31823.7 -csv,independent,uniform,1,4,all_late,262144,4699648,7,4,262144,4,84710.5 -csv,unmasked,uniform,1,4,all_early,65536,4330624,1,1,65536,1,24905.0 -csv,combined,uniform,1,4,all_early,65536,4330624,1,1,65536,1,30601.5 -csv,independent,uniform,1,4,all_early,262144,4699648,7,4,262144,4,88719.6 -csv,unmasked,uniform,1,8,heuristic,65536,8535168,3,2,65536,1,33333.5 -csv,combined,uniform,1,8,heuristic,65536,8535168,3,2,65536,1,38368.6 -csv,independent,uniform,1,8,heuristic,524288,9398272,15,8,524288,8,192389.5 -csv,unmasked,uniform,1,8,all_late,65536,8535168,3,2,65536,1,29281.4 -csv,combined,uniform,1,8,all_late,65536,8535168,3,2,65536,1,33361.2 -csv,independent,uniform,1,8,all_late,524288,9398272,15,8,524288,8,184600.6 -csv,unmasked,uniform,1,8,all_early,65536,8535168,3,2,65536,1,31409.1 -csv,combined,uniform,1,8,all_early,65536,8535168,3,2,65536,1,34904.2 -csv,independent,uniform,1,8,all_early,524288,9398272,15,8,524288,8,186247.6 -csv,unmasked,clustered,0.001,1,heuristic,65536,127744,1,1,65536,1,17288.7 -csv,combined,clustered,0.001,1,heuristic,64,3000,2,1,64,1,1349.7 -csv,independent,clustered,0.001,1,heuristic,64,3000,2,1,64,1,1393.8 -csv,unmasked,clustered,0.001,1,all_late,65536,127744,1,1,65536,1,17680.3 -csv,combined,clustered,0.001,1,all_late,64,3000,2,1,64,1,1134.5 -csv,independent,clustered,0.001,1,all_late,64,3000,2,1,64,1,1200.0 -csv,unmasked,clustered,0.001,1,all_early,65536,127744,1,1,65536,1,17862.3 -csv,combined,clustered,0.001,1,all_early,64,3000,2,1,64,1,1240.1 -csv,independent,clustered,0.001,1,all_early,64,3000,2,1,64,1,1217.3 -csv,unmasked,clustered,0.001,2,heuristic,65536,132552,1,1,65536,1,18578.6 -csv,combined,clustered,0.001,2,heuristic,0,0,0,0,0,0,349.3 -csv,independent,clustered,0.001,2,heuristic,128,6008,4,2,128,2,2546.5 -csv,unmasked,clustered,0.001,2,all_late,65536,132552,1,1,65536,1,18705.1 -csv,combined,clustered,0.001,2,all_late,0,0,0,0,0,0,444.7 -csv,independent,clustered,0.001,2,all_late,128,6008,4,2,128,2,2665.6 -csv,unmasked,clustered,0.001,2,all_early,65536,132552,1,1,65536,1,19036.3 -csv,combined,clustered,0.001,2,all_early,0,0,0,0,0,0,323.1 -csv,independent,clustered,0.001,2,all_early,128,6008,4,2,128,2,2575.0 -csv,unmasked,clustered,0.001,4,heuristic,65536,143048,1,1,65536,1,21828.1 -csv,combined,clustered,0.001,4,heuristic,0,0,0,0,0,0,439.8 -csv,independent,clustered,0.001,4,heuristic,320,14184,9,4,320,5,4593.2 -csv,unmasked,clustered,0.001,4,all_late,65536,143048,1,1,65536,1,32846.8 -csv,combined,clustered,0.001,4,all_late,0,0,0,0,0,0,407.9 -csv,independent,clustered,0.001,4,all_late,320,14184,9,4,320,5,5826.8 -csv,unmasked,clustered,0.001,4,all_early,65536,143048,1,1,65536,1,22800.2 -csv,combined,clustered,0.001,4,all_early,0,0,0,0,0,0,445.2 -csv,independent,clustered,0.001,4,all_early,320,14184,9,4,320,5,5651.5 -csv,unmasked,clustered,0.001,8,heuristic,65536,153648,1,1,65536,1,28765.2 -csv,combined,clustered,0.001,8,heuristic,0,0,0,0,0,0,545.6 -csv,independent,clustered,0.001,8,heuristic,640,28664,16,6,640,10,10190.4 -csv,unmasked,clustered,0.001,8,all_late,65536,153648,1,1,65536,1,29569.5 -csv,combined,clustered,0.001,8,all_late,0,0,0,0,0,0,662.0 -csv,independent,clustered,0.001,8,all_late,640,28664,16,6,640,10,8867.6 -csv,unmasked,clustered,0.001,8,all_early,65536,153648,1,1,65536,1,28225.6 -csv,combined,clustered,0.001,8,all_early,0,0,0,0,0,0,538.6 -csv,independent,clustered,0.001,8,all_early,640,28664,16,6,640,10,8907.1 -csv,unmasked,clustered,0.01,1,heuristic,65536,130448,1,1,65536,1,16859.1 -csv,combined,clustered,0.01,1,heuristic,704,31504,6,1,704,11,1811.7 -csv,independent,clustered,0.01,1,heuristic,704,31504,6,1,704,11,1488.3 -csv,unmasked,clustered,0.01,1,all_late,65536,130448,1,1,65536,1,14315.9 -csv,combined,clustered,0.01,1,all_late,704,31504,6,1,704,11,1361.4 -csv,independent,clustered,0.01,1,all_late,704,31504,6,1,704,11,1395.5 -csv,unmasked,clustered,0.01,1,all_early,65536,130448,1,1,65536,1,15084.2 -csv,combined,clustered,0.01,1,all_early,704,31504,6,1,704,11,1493.1 -csv,independent,clustered,0.01,1,all_early,704,31504,6,1,704,11,1494.7 -csv,unmasked,clustered,0.01,2,heuristic,65536,135832,2,1,65536,1,18830.3 -csv,combined,clustered,0.01,2,heuristic,0,0,0,0,0,0,342.8 -csv,independent,clustered,0.01,2,heuristic,1216,50136,13,2,1216,19,2957.1 -csv,unmasked,clustered,0.01,2,all_late,65536,135832,2,1,65536,1,18595.7 -csv,combined,clustered,0.01,2,all_late,0,0,0,0,0,0,342.6 -csv,independent,clustered,0.01,2,all_late,1216,50136,13,2,1216,19,3758.7 -csv,unmasked,clustered,0.01,2,all_early,65536,135832,2,1,65536,1,24837.5 -csv,combined,clustered,0.01,2,all_early,0,0,0,0,0,0,369.2 -csv,independent,clustered,0.01,2,all_early,1216,50136,13,2,1216,19,4310.0 -csv,unmasked,clustered,0.01,4,heuristic,65536,145968,4,1,65536,1,31446.9 -csv,combined,clustered,0.01,4,heuristic,0,0,0,0,0,0,411.9 -csv,independent,clustered,0.01,4,heuristic,2112,91200,24,4,2112,33,6281.1 -csv,unmasked,clustered,0.01,4,all_late,65536,145968,4,1,65536,1,21663.8 -csv,combined,clustered,0.01,4,all_late,0,0,0,0,0,0,414.6 -csv,independent,clustered,0.01,4,all_late,2112,91200,24,4,2112,33,6084.2 -csv,unmasked,clustered,0.01,4,all_early,65536,145968,4,1,65536,1,22057.9 -csv,combined,clustered,0.01,4,all_early,0,0,0,0,0,0,471.5 -csv,independent,clustered,0.01,4,all_early,2112,91200,24,4,2112,33,5734.3 -csv,unmasked,clustered,0.01,8,heuristic,65536,169416,8,1,65536,1,28629.3 -csv,combined,clustered,0.01,8,heuristic,0,0,0,0,0,0,498.4 -csv,independent,clustered,0.01,8,heuristic,4544,214248,51,8,4544,71,14205.4 -csv,unmasked,clustered,0.01,8,all_late,65536,169416,8,1,65536,1,30549.0 -csv,combined,clustered,0.01,8,all_late,0,0,0,0,0,0,772.3 -csv,independent,clustered,0.01,8,all_late,4544,214248,51,8,4544,71,14172.8 -csv,unmasked,clustered,0.01,8,all_early,65536,169416,8,1,65536,1,27991.2 -csv,combined,clustered,0.01,8,all_early,0,0,0,0,0,0,534.8 -csv,independent,clustered,0.01,8,all_early,4544,214248,51,8,4544,71,12688.8 -csv,unmasked,clustered,0.1,1,heuristic,65536,159928,1,1,65536,1,17550.2 -csv,combined,clustered,0.1,1,heuristic,6528,153736,2,1,6528,93,3527.5 -csv,independent,clustered,0.1,1,heuristic,6528,153736,2,1,6528,93,3605.4 -csv,unmasked,clustered,0.1,1,all_late,65536,159928,1,1,65536,1,26734.2 -csv,combined,clustered,0.1,1,all_late,6528,153736,2,1,6528,93,3673.4 -csv,independent,clustered,0.1,1,all_late,6528,153736,2,1,6528,93,3525.3 -csv,unmasked,clustered,0.1,1,all_early,65536,159928,1,1,65536,1,17016.6 -csv,combined,clustered,0.1,1,all_early,6528,153736,2,1,6528,93,3702.6 -csv,independent,clustered,0.1,1,all_early,6528,153736,2,1,6528,93,3671.7 -csv,unmasked,clustered,0.1,2,heuristic,65536,194472,2,1,65536,1,18679.5 -csv,combined,clustered,0.1,2,heuristic,832,80512,10,1,832,13,1934.0 -csv,independent,clustered,0.1,2,heuristic,12800,308184,5,2,12800,183,6508.4 -csv,unmasked,clustered,0.1,2,all_late,65536,194472,2,1,65536,1,17450.5 -csv,combined,clustered,0.1,2,all_late,832,80512,10,1,832,13,1785.9 -csv,independent,clustered,0.1,2,all_late,12800,308184,5,2,12800,183,6609.4 -csv,unmasked,clustered,0.1,2,all_early,65536,194472,2,1,65536,1,18979.6 -csv,combined,clustered,0.1,2,all_early,832,80512,10,1,832,13,2304.7 -csv,independent,clustered,0.1,2,all_early,12800,308184,5,2,12800,183,9397.0 -csv,unmasked,clustered,0.1,4,heuristic,65536,263544,4,1,65536,1,23434.7 -csv,combined,clustered,0.1,4,heuristic,0,0,0,0,0,0,424.7 -csv,independent,clustered,0.1,4,heuristic,25344,619256,10,4,25344,361,13853.0 -csv,unmasked,clustered,0.1,4,all_late,65536,263544,4,1,65536,1,23291.2 -csv,combined,clustered,0.1,4,all_late,0,0,0,0,0,0,464.7 -csv,independent,clustered,0.1,4,all_late,25344,619256,10,4,25344,361,13137.1 -csv,unmasked,clustered,0.1,4,all_early,65536,263544,4,1,65536,1,22634.4 -csv,combined,clustered,0.1,4,all_early,0,0,0,0,0,0,396.5 -csv,independent,clustered,0.1,4,all_early,25344,619256,10,4,25344,361,13726.8 -csv,unmasked,clustered,0.1,8,heuristic,65536,406864,8,1,65536,1,29721.0 -csv,combined,clustered,0.1,8,heuristic,0,0,0,0,0,0,531.7 -csv,independent,clustered,0.1,8,heuristic,51456,1250448,20,8,51456,725,31067.3 -csv,unmasked,clustered,0.1,8,all_late,65536,406864,8,1,65536,1,30905.2 -csv,combined,clustered,0.1,8,all_late,0,0,0,0,0,0,723.6 -csv,independent,clustered,0.1,8,all_late,51456,1250448,20,8,51456,725,30954.9 -csv,unmasked,clustered,0.1,8,all_early,65536,406864,8,1,65536,1,31146.3 -csv,combined,clustered,0.1,8,all_early,0,0,0,0,0,0,593.9 -csv,independent,clustered,0.1,8,all_early,51456,1250448,20,8,51456,725,31975.3 -csv,unmasked,clustered,0.5,1,heuristic,65536,1180776,1,1,65536,1,17713.7 -csv,combined,clustered,0.5,1,heuristic,32512,1086016,21,1,32512,249,13810.5 -csv,independent,clustered,0.5,1,heuristic,32512,1086016,21,1,32512,249,14064.5 -csv,unmasked,clustered,0.5,1,all_late,65536,1180776,1,1,65536,1,18285.2 -csv,combined,clustered,0.5,1,all_late,32512,1086016,21,1,32512,249,13620.8 -csv,independent,clustered,0.5,1,all_late,32512,1086016,21,1,32512,249,12963.1 -csv,unmasked,clustered,0.5,1,all_early,65536,1180776,1,1,65536,1,18000.3 -csv,combined,clustered,0.5,1,all_early,32512,1086016,21,1,32512,249,12600.8 -csv,independent,clustered,0.5,1,all_early,32512,1086016,21,1,32512,249,12934.5 -csv,unmasked,clustered,0.5,2,heuristic,65536,1299824,1,1,65536,1,21886.1 -csv,combined,clustered,0.5,2,heuristic,15232,915328,62,1,15232,179,10748.3 -csv,independent,clustered,0.5,2,heuristic,64640,1328816,23,2,64640,509,27227.0 -csv,unmasked,clustered,0.5,2,all_late,65536,1299824,1,1,65536,1,20922.2 -csv,combined,clustered,0.5,2,all_late,15232,915328,62,1,15232,179,9633.0 -csv,independent,clustered,0.5,2,all_late,64640,1328816,23,2,64640,509,28997.0 -csv,unmasked,clustered,0.5,2,all_early,65536,1299824,1,1,65536,1,28517.0 -csv,combined,clustered,0.5,2,all_early,15232,915328,62,1,15232,179,9202.2 -csv,independent,clustered,0.5,2,all_early,64640,1328816,23,2,64640,509,28608.3 -csv,unmasked,clustered,0.5,4,heuristic,65536,2474528,3,1,65536,1,25104.4 -csv,combined,clustered,0.5,4,heuristic,3328,739232,92,1,3328,52,6431.5 -csv,independent,clustered,0.5,4,heuristic,128896,2685664,42,4,128896,1032,55687.3 -csv,unmasked,clustered,0.5,4,all_late,65536,2474528,3,1,65536,1,27188.2 -csv,combined,clustered,0.5,4,all_late,3328,739232,92,1,3328,52,6643.1 -csv,independent,clustered,0.5,4,all_late,128896,2685664,42,4,128896,1032,55409.4 -csv,unmasked,clustered,0.5,4,all_early,65536,2474528,3,1,65536,1,25417.3 -csv,combined,clustered,0.5,4,all_early,3328,739232,92,1,3328,52,6150.2 -csv,independent,clustered,0.5,4,all_early,128896,2685664,42,4,128896,1032,51132.5 -csv,unmasked,clustered,0.5,8,heuristic,65536,6701944,3,1,65536,1,33187.9 -csv,combined,clustered,0.5,8,heuristic,192,92312,27,1,192,3,2555.5 -csv,independent,clustered,0.5,8,heuristic,258368,7133064,112,8,258368,2083,106484.8 -csv,unmasked,clustered,0.5,8,all_late,65536,6701944,3,1,65536,1,36840.1 -csv,combined,clustered,0.5,8,all_late,192,92312,27,1,192,3,3105.9 -csv,independent,clustered,0.5,8,all_late,258368,7133064,112,8,258368,2083,114315.0 -csv,unmasked,clustered,0.5,8,all_early,65536,6701944,3,1,65536,1,33919.9 -csv,combined,clustered,0.5,8,all_early,192,92312,27,1,192,3,4259.5 -csv,independent,clustered,0.5,8,all_early,258368,7133064,112,8,258368,2083,99194.9 -csv,unmasked,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,17438.1 -csv,combined,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,22303.5 -csv,independent,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,23202.6 -csv,unmasked,clustered,1,1,all_late,65536,1175680,1,1,65536,1,17008.5 -csv,combined,clustered,1,1,all_late,65536,1175680,1,1,65536,1,22348.3 -csv,independent,clustered,1,1,all_late,65536,1175680,1,1,65536,1,22428.3 -csv,unmasked,clustered,1,1,all_early,65536,1175680,1,1,65536,1,21278.3 -csv,combined,clustered,1,1,all_early,65536,1175680,1,1,65536,1,23035.9 -csv,independent,clustered,1,1,all_early,65536,1175680,1,1,65536,1,21643.5 -csv,unmasked,clustered,1,2,heuristic,65536,2227328,1,1,65536,1,18154.8 -csv,combined,clustered,1,2,heuristic,65536,2227328,1,1,65536,1,23203.0 -csv,independent,clustered,1,2,heuristic,131072,2350336,3,2,131072,2,43737.0 -csv,unmasked,clustered,1,2,all_late,65536,2227328,1,1,65536,1,19080.1 -csv,combined,clustered,1,2,all_late,65536,2227328,1,1,65536,1,22842.6 -csv,independent,clustered,1,2,all_late,131072,2350336,3,2,131072,2,42759.6 -csv,unmasked,clustered,1,2,all_early,65536,2227328,1,1,65536,1,17399.3 -csv,combined,clustered,1,2,all_early,65536,2227328,1,1,65536,1,22823.0 -csv,independent,clustered,1,2,all_early,131072,2350336,3,2,131072,2,46323.5 -csv,unmasked,clustered,1,4,heuristic,65536,4330624,1,1,65536,1,23527.0 -csv,combined,clustered,1,4,heuristic,65536,4330624,1,1,65536,1,29553.0 -csv,independent,clustered,1,4,heuristic,262144,4699648,7,4,262144,4,96698.4 -csv,unmasked,clustered,1,4,all_late,65536,4330624,1,1,65536,1,22879.7 -csv,combined,clustered,1,4,all_late,65536,4330624,1,1,65536,1,27380.1 -csv,independent,clustered,1,4,all_late,262144,4699648,7,4,262144,4,88048.9 -csv,unmasked,clustered,1,4,all_early,65536,4330624,1,1,65536,1,22879.7 -csv,combined,clustered,1,4,all_early,65536,4330624,1,1,65536,1,28049.7 -csv,independent,clustered,1,4,all_early,262144,4699648,7,4,262144,4,86906.9 -csv,unmasked,clustered,1,8,heuristic,65536,8535168,3,2,65536,1,30948.2 -csv,combined,clustered,1,8,heuristic,65536,8535168,3,2,65536,1,39615.4 -csv,independent,clustered,1,8,heuristic,524288,9398272,15,8,524288,8,183067.9 -csv,unmasked,clustered,1,8,all_late,65536,8535168,3,2,65536,1,29305.8 -csv,combined,clustered,1,8,all_late,65536,8535168,3,2,65536,1,38264.6 -csv,independent,clustered,1,8,all_late,524288,9398272,15,8,524288,8,212102.9 -csv,unmasked,clustered,1,8,all_early,65536,8535168,3,2,65536,1,30725.3 -csv,combined,clustered,1,8,all_early,65536,8535168,3,2,65536,1,35065.9 -csv,independent,clustered,1,8,all_early,524288,9398272,15,8,524288,8,187848.2 +csv,unmasked,uniform,0.001,1,heuristic,65536,127296,1,1,65536,1,24016.0 +csv,combined,uniform,0.001,1,heuristic,46,97424,6,1,46,46,1544.5 +csv,independent,uniform,0.001,1,heuristic,46,97424,6,1,46,46,1252.2 +csv,unmasked,uniform,0.001,1,all_late,65536,127296,1,1,65536,1,15800.4 +csv,combined,uniform,0.001,1,all_late,46,97424,6,1,46,46,1645.5 +csv,independent,uniform,0.001,1,all_late,46,97424,6,1,46,46,1497.1 +csv,unmasked,uniform,0.001,1,all_early,65536,127296,1,1,65536,1,17531.7 +csv,combined,uniform,0.001,1,all_early,46,97424,6,1,46,46,1584.7 +csv,independent,uniform,0.001,1,all_early,46,97424,6,1,46,46,1682.3 +csv,unmasked,uniform,0.001,2,heuristic,65536,131560,1,1,65536,1,21805.8 +csv,combined,uniform,0.001,2,heuristic,1,6536,2,1,1,1,1362.8 +csv,independent,uniform,0.001,2,heuristic,112,202952,11,2,112,112,3203.1 +csv,unmasked,uniform,0.001,2,all_late,65536,131560,1,1,65536,1,25310.5 +csv,combined,uniform,0.001,2,all_late,1,6536,2,1,1,1,1286.8 +csv,independent,uniform,0.001,2,all_late,112,202952,11,2,112,112,2734.2 +csv,unmasked,uniform,0.001,2,all_early,65536,131560,1,1,65536,1,20979.8 +csv,combined,uniform,0.001,2,all_early,1,6536,2,1,1,1,2878.1 +csv,independent,uniform,0.001,2,all_early,112,202952,11,2,112,112,2883.7 +csv,unmasked,uniform,0.001,4,heuristic,65536,140808,1,1,65536,1,30442.0 +csv,combined,uniform,0.001,4,heuristic,0,0,0,0,0,0,406.1 +csv,independent,uniform,0.001,4,heuristic,245,419424,23,4,245,245,6820.0 +csv,unmasked,uniform,0.001,4,all_late,65536,140808,1,1,65536,1,30429.1 +csv,combined,uniform,0.001,4,all_late,0,0,0,0,0,0,403.3 +csv,independent,uniform,0.001,4,all_late,245,419424,23,4,245,245,6491.9 +csv,unmasked,uniform,0.001,4,all_early,65536,140808,1,1,65536,1,33350.9 +csv,combined,uniform,0.001,4,all_early,0,0,0,0,0,0,407.4 +csv,independent,uniform,0.001,4,all_early,245,419424,23,4,245,245,5815.7 +csv,unmasked,uniform,0.001,8,heuristic,65536,159736,1,1,65536,1,42239.5 +csv,combined,uniform,0.001,8,heuristic,0,0,0,0,0,0,491.3 +csv,independent,uniform,0.001,8,heuristic,531,849024,42,8,531,530,12051.2 +csv,unmasked,uniform,0.001,8,all_late,65536,159736,1,1,65536,1,40645.3 +csv,combined,uniform,0.001,8,all_late,0,0,0,0,0,0,507.5 +csv,independent,uniform,0.001,8,all_late,531,849024,42,8,531,530,10975.7 +csv,unmasked,uniform,0.001,8,all_early,65536,159736,1,1,65536,1,39413.5 +csv,combined,uniform,0.001,8,all_early,0,0,0,0,0,0,505.8 +csv,independent,uniform,0.001,8,all_early,531,849024,42,8,531,530,10353.0 +csv,unmasked,uniform,0.01,1,heuristic,65536,136160,1,1,65536,1,18135.0 +csv,combined,uniform,0.01,1,heuristic,692,136160,1,1,692,689,2639.7 +csv,independent,uniform,0.01,1,heuristic,692,136160,1,1,692,689,2579.2 +csv,unmasked,uniform,0.01,1,all_late,65536,136160,1,1,65536,1,16631.0 +csv,combined,uniform,0.01,1,all_late,692,136160,1,1,692,689,2566.7 +csv,independent,uniform,0.01,1,all_late,692,136160,1,1,692,689,2228.5 +csv,unmasked,uniform,0.01,1,all_early,65536,136160,1,1,65536,1,17896.7 +csv,combined,uniform,0.01,1,all_early,692,136160,1,1,692,689,2241.1 +csv,independent,uniform,0.01,1,all_early,692,136160,1,1,692,689,1777.5 +csv,unmasked,uniform,0.01,2,heuristic,65536,147720,2,1,65536,1,19546.7 +csv,combined,uniform,0.01,2,heuristic,9,30920,10,1,9,9,1531.2 +csv,independent,uniform,0.01,2,heuristic,1354,271752,3,2,1354,1341,4534.2 +csv,unmasked,uniform,0.01,2,all_late,65536,147720,2,1,65536,1,18917.5 +csv,combined,uniform,0.01,2,all_late,9,30920,10,1,9,9,1527.1 +csv,independent,uniform,0.01,2,all_late,1354,271752,3,2,1354,1341,3806.6 +csv,unmasked,uniform,0.01,2,all_early,65536,147720,2,1,65536,1,19574.9 +csv,combined,uniform,0.01,2,all_early,9,30920,10,1,9,9,2053.9 +csv,independent,uniform,0.01,2,all_early,1354,271752,3,2,1354,1341,3780.3 +csv,unmasked,uniform,0.01,4,heuristic,65536,170624,4,1,65536,1,24855.4 +csv,combined,uniform,0.01,4,heuristic,0,0,0,0,0,0,398.5 +csv,independent,uniform,0.01,4,heuristic,2655,542720,7,4,2655,2635,9632.9 +csv,unmasked,uniform,0.01,4,all_late,65536,170624,4,1,65536,1,23724.7 +csv,combined,uniform,0.01,4,all_late,0,0,0,0,0,0,473.9 +csv,independent,uniform,0.01,4,all_late,2655,542720,7,4,2655,2635,7868.2 +csv,unmasked,uniform,0.01,4,all_early,65536,170624,4,1,65536,1,23248.8 +csv,combined,uniform,0.01,4,all_early,0,0,0,0,0,0,413.8 +csv,independent,uniform,0.01,4,all_early,2655,542720,7,4,2655,2635,8507.4 +csv,unmasked,uniform,0.01,8,heuristic,65536,217040,8,1,65536,1,30112.8 +csv,combined,uniform,0.01,8,heuristic,0,0,0,0,0,0,524.3 +csv,independent,uniform,0.01,8,heuristic,5304,1085264,15,8,5304,5266,16802.4 +csv,unmasked,uniform,0.01,8,all_late,65536,217040,8,1,65536,1,33966.7 +csv,combined,uniform,0.01,8,all_late,0,0,0,0,0,0,822.7 +csv,independent,uniform,0.01,8,all_late,5304,1085264,15,8,5304,5266,20736.8 +csv,unmasked,uniform,0.01,8,all_early,65536,217040,8,1,65536,1,32708.4 +csv,combined,uniform,0.01,8,all_early,0,0,0,0,0,0,530.1 +csv,independent,uniform,0.01,8,all_early,5304,1085264,15,8,5304,5266,21045.4 +csv,unmasked,uniform,0.1,1,heuristic,65536,195416,1,1,65536,1,18725.8 +csv,combined,uniform,0.1,1,heuristic,6606,195416,1,1,6606,5937,8030.2 +csv,independent,uniform,0.1,1,heuristic,6606,195416,1,1,6606,5937,8361.5 +csv,unmasked,uniform,0.1,1,all_late,65536,195416,1,1,65536,1,18824.2 +csv,combined,uniform,0.1,1,all_late,6606,195416,1,1,6606,5937,8197.7 +csv,independent,uniform,0.1,1,all_late,6606,195416,1,1,6606,5937,6921.2 +csv,unmasked,uniform,0.1,1,all_early,65536,195416,1,1,65536,1,22099.0 +csv,combined,uniform,0.1,1,all_early,6606,195416,1,1,6606,5937,7316.2 +csv,independent,uniform,0.1,1,all_early,6606,195416,1,1,6606,5937,7644.1 +csv,unmasked,uniform,0.1,2,heuristic,65536,266584,2,1,65536,1,21609.5 +csv,combined,uniform,0.1,2,heuristic,679,266584,2,1,679,672,3642.5 +csv,independent,uniform,0.1,2,heuristic,13194,390616,3,2,13194,11864,16968.7 +csv,unmasked,uniform,0.1,2,all_late,65536,266584,2,1,65536,1,22079.7 +csv,combined,uniform,0.1,2,all_late,679,266584,2,1,679,672,3740.4 +csv,independent,uniform,0.1,2,all_late,13194,390616,3,2,13194,11864,17302.2 +csv,unmasked,uniform,0.1,2,all_early,65536,266584,2,1,65536,1,19469.7 +csv,combined,uniform,0.1,2,all_early,679,266584,2,1,679,672,2718.7 +csv,independent,uniform,0.1,2,all_early,13194,390616,3,2,13194,11864,15205.6 +csv,unmasked,uniform,0.1,4,heuristic,65536,409560,4,1,65536,1,24118.1 +csv,combined,uniform,0.1,4,heuristic,8,143320,18,1,8,8,2791.2 +csv,independent,uniform,0.1,4,heuristic,26435,781656,7,4,26435,23772,34299.3 +csv,unmasked,uniform,0.1,4,all_late,65536,409560,4,1,65536,1,24430.5 +csv,combined,uniform,0.1,4,all_late,8,143320,18,1,8,8,2401.3 +csv,independent,uniform,0.1,4,all_late,26435,781656,7,4,26435,23772,30603.7 +csv,unmasked,uniform,0.1,4,all_early,65536,409560,4,1,65536,1,25086.3 +csv,combined,uniform,0.1,4,all_early,8,143320,18,1,8,8,2718.3 +csv,independent,uniform,0.1,4,all_early,26435,781656,7,4,26435,23772,30311.2 +csv,unmasked,uniform,0.1,8,heuristic,65536,692016,8,1,65536,1,46024.1 +csv,combined,uniform,0.1,8,heuristic,0,0,0,0,0,0,542.2 +csv,independent,uniform,0.1,8,heuristic,52513,1560240,15,8,52513,47298,60455.2 +csv,unmasked,uniform,0.1,8,all_late,65536,692016,8,1,65536,1,41763.7 +csv,combined,uniform,0.1,8,all_late,0,0,0,0,0,0,536.6 +csv,independent,uniform,0.1,8,all_late,52513,1560240,15,8,52513,47298,64980.0 +csv,unmasked,uniform,0.1,8,all_early,65536,692016,8,1,65536,1,43534.6 +csv,combined,uniform,0.1,8,all_early,0,0,0,0,0,0,537.6 +csv,independent,uniform,0.1,8,all_early,52513,1560240,15,8,52513,47298,61913.7 +csv,unmasked,uniform,0.5,1,heuristic,65536,1208448,1,1,65536,1,18422.4 +csv,combined,uniform,0.5,1,heuristic,33120,1208448,1,1,33120,16289,19593.1 +csv,independent,uniform,0.5,1,heuristic,33120,1208448,1,1,33120,16289,20912.7 +csv,unmasked,uniform,0.5,1,all_late,65536,1208448,1,1,65536,1,21312.6 +csv,combined,uniform,0.5,1,all_late,33120,1208448,1,1,33120,16289,24373.9 +csv,independent,uniform,0.5,1,all_late,33120,1208448,1,1,33120,16289,19775.3 +csv,unmasked,uniform,0.5,1,all_early,65536,1208448,1,1,65536,1,16434.5 +csv,combined,uniform,0.5,1,all_early,33120,1208448,1,1,33120,16289,18328.4 +csv,independent,uniform,0.5,1,all_early,33120,1208448,1,1,33120,16289,18937.8 +csv,unmasked,uniform,0.5,2,heuristic,65536,2292864,1,1,65536,1,29535.2 +csv,combined,uniform,0.5,2,heuristic,16591,2292864,1,1,16591,12357,19743.4 +csv,independent,uniform,0.5,2,heuristic,65891,2415872,3,2,65891,32770,42360.5 +csv,unmasked,uniform,0.5,2,all_late,65536,2292864,1,1,65536,1,22215.1 +csv,combined,uniform,0.5,2,all_late,16591,2292864,1,1,16591,12357,16514.0 +csv,independent,uniform,0.5,2,all_late,65891,2415872,3,2,65891,32770,39084.9 +csv,unmasked,uniform,0.5,2,all_early,65536,2292864,1,1,65536,1,23726.8 +csv,combined,uniform,0.5,2,all_early,16591,2292864,1,1,16591,12357,18719.2 +csv,independent,uniform,0.5,2,all_early,65891,2415872,3,2,65891,32770,42035.6 +csv,unmasked,uniform,0.5,4,heuristic,65536,2541824,2,1,65536,1,27552.8 +csv,combined,uniform,0.5,4,heuristic,4074,2541824,2,1,4074,3809,12330.7 +csv,independent,uniform,0.5,4,heuristic,131294,2912640,7,4,131294,65436,78100.2 +csv,unmasked,uniform,0.5,4,all_late,65536,2541824,2,1,65536,1,26875.9 +csv,combined,uniform,0.5,4,all_late,4074,2541824,2,1,4074,3809,10528.2 +csv,independent,uniform,0.5,4,all_late,131294,2912640,7,4,131294,65436,86225.4 +csv,unmasked,uniform,0.5,4,all_early,65536,2541824,2,1,65536,1,29643.7 +csv,combined,uniform,0.5,4,all_early,4074,2541824,2,1,4074,3809,13862.8 +csv,independent,uniform,0.5,4,all_early,131294,2912640,7,4,131294,65436,78419.8 +csv,unmasked,uniform,0.5,8,heuristic,65536,4958336,5,1,65536,1,38960.4 +csv,combined,uniform,0.5,8,heuristic,247,3195520,272,1,247,246,11203.9 +csv,independent,uniform,0.5,8,heuristic,261893,5824256,15,8,261893,131042,183889.0 +csv,unmasked,uniform,0.5,8,all_late,65536,4958336,5,1,65536,1,45476.9 +csv,combined,uniform,0.5,8,all_late,247,3195520,272,1,247,246,13191.6 +csv,independent,uniform,0.5,8,all_late,261893,5824256,15,8,261893,131042,178344.1 +csv,unmasked,uniform,0.5,8,all_early,65536,4958336,5,1,65536,1,39473.0 +csv,combined,uniform,0.5,8,all_early,247,3195520,272,1,247,246,13423.0 +csv,independent,uniform,0.5,8,all_early,261893,5824256,15,8,261893,131042,193195.9 +csv,unmasked,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,26147.6 +csv,combined,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,24901.8 +csv,independent,uniform,1,1,heuristic,65536,1175680,1,1,65536,1,23463.0 +csv,unmasked,uniform,1,1,all_late,65536,1175680,1,1,65536,1,17807.5 +csv,combined,uniform,1,1,all_late,65536,1175680,1,1,65536,1,21580.8 +csv,independent,uniform,1,1,all_late,65536,1175680,1,1,65536,1,21223.3 +csv,unmasked,uniform,1,1,all_early,65536,1175680,1,1,65536,1,18792.7 +csv,combined,uniform,1,1,all_early,65536,1175680,1,1,65536,1,23808.7 +csv,independent,uniform,1,1,all_early,65536,1175680,1,1,65536,1,24174.1 +csv,unmasked,uniform,1,2,heuristic,65536,2227328,1,1,65536,1,20804.2 +csv,combined,uniform,1,2,heuristic,65536,2227328,1,1,65536,1,26007.1 +csv,independent,uniform,1,2,heuristic,131072,2350336,3,2,131072,2,59763.5 +csv,unmasked,uniform,1,2,all_late,65536,2227328,1,1,65536,1,19138.5 +csv,combined,uniform,1,2,all_late,65536,2227328,1,1,65536,1,24998.2 +csv,independent,uniform,1,2,all_late,131072,2350336,3,2,131072,2,43584.5 +csv,unmasked,uniform,1,2,all_early,65536,2227328,1,1,65536,1,21161.6 +csv,combined,uniform,1,2,all_early,65536,2227328,1,1,65536,1,23896.9 +csv,independent,uniform,1,2,all_early,131072,2350336,3,2,131072,2,43324.4 +csv,unmasked,uniform,1,4,heuristic,65536,4330624,1,1,65536,1,27931.8 +csv,combined,uniform,1,4,heuristic,65536,4330624,1,1,65536,1,31766.4 +csv,independent,uniform,1,4,heuristic,262144,4699648,7,4,262144,4,99230.9 +csv,unmasked,uniform,1,4,all_late,65536,4330624,1,1,65536,1,25383.7 +csv,combined,uniform,1,4,all_late,65536,4330624,1,1,65536,1,41301.3 +csv,independent,uniform,1,4,all_late,262144,4699648,7,4,262144,4,91851.0 +csv,unmasked,uniform,1,4,all_early,65536,4330624,1,1,65536,1,22843.4 +csv,combined,uniform,1,4,all_early,65536,4330624,1,1,65536,1,27049.8 +csv,independent,uniform,1,4,all_early,262144,4699648,7,4,262144,4,120100.5 +csv,unmasked,uniform,1,8,heuristic,65536,8535168,3,2,65536,1,35395.9 +csv,combined,uniform,1,8,heuristic,65536,8535168,3,2,65536,1,35898.9 +csv,independent,uniform,1,8,heuristic,524288,9398272,15,8,524288,8,198529.0 +csv,unmasked,uniform,1,8,all_late,65536,8535168,3,2,65536,1,34263.6 +csv,combined,uniform,1,8,all_late,65536,8535168,3,2,65536,1,41006.4 +csv,independent,uniform,1,8,all_late,524288,9398272,15,8,524288,8,187930.6 +csv,unmasked,uniform,1,8,all_early,65536,8535168,3,2,65536,1,37950.0 +csv,combined,uniform,1,8,all_early,65536,8535168,3,2,65536,1,34679.8 +csv,independent,uniform,1,8,all_early,524288,9398272,15,8,524288,8,205330.2 +csv,unmasked,clustered,0.001,1,heuristic,65536,127744,1,1,65536,1,20594.4 +csv,combined,clustered,0.001,1,heuristic,64,3000,2,1,64,1,1426.1 +csv,independent,clustered,0.001,1,heuristic,64,3000,2,1,64,1,1120.3 +csv,unmasked,clustered,0.001,1,all_late,65536,127744,1,1,65536,1,22915.7 +csv,combined,clustered,0.001,1,all_late,64,3000,2,1,64,1,1426.6 +csv,independent,clustered,0.001,1,all_late,64,3000,2,1,64,1,1174.3 +csv,unmasked,clustered,0.001,1,all_early,65536,127744,1,1,65536,1,19783.8 +csv,combined,clustered,0.001,1,all_early,64,3000,2,1,64,1,1307.2 +csv,independent,clustered,0.001,1,all_early,64,3000,2,1,64,1,1321.8 +csv,unmasked,clustered,0.001,2,heuristic,65536,132552,1,1,65536,1,21547.8 +csv,combined,clustered,0.001,2,heuristic,0,0,0,0,0,0,411.4 +csv,independent,clustered,0.001,2,heuristic,128,6008,4,2,128,2,2328.3 +csv,unmasked,clustered,0.001,2,all_late,65536,132552,1,1,65536,1,21316.7 +csv,combined,clustered,0.001,2,all_late,0,0,0,0,0,0,384.1 +csv,independent,clustered,0.001,2,all_late,128,6008,4,2,128,2,3649.6 +csv,unmasked,clustered,0.001,2,all_early,65536,132552,1,1,65536,1,26920.3 +csv,combined,clustered,0.001,2,all_early,0,0,0,0,0,0,481.9 +csv,independent,clustered,0.001,2,all_early,128,6008,4,2,128,2,2883.0 +csv,unmasked,clustered,0.001,4,heuristic,65536,143048,1,1,65536,1,25835.9 +csv,combined,clustered,0.001,4,heuristic,0,0,0,0,0,0,399.4 +csv,independent,clustered,0.001,4,heuristic,320,14184,9,4,320,5,4418.3 +csv,unmasked,clustered,0.001,4,all_late,65536,143048,1,1,65536,1,23935.4 +csv,combined,clustered,0.001,4,all_late,0,0,0,0,0,0,435.9 +csv,independent,clustered,0.001,4,all_late,320,14184,9,4,320,5,4936.9 +csv,unmasked,clustered,0.001,4,all_early,65536,143048,1,1,65536,1,25491.9 +csv,combined,clustered,0.001,4,all_early,0,0,0,0,0,0,409.9 +csv,independent,clustered,0.001,4,all_early,320,14184,9,4,320,5,4398.2 +csv,unmasked,clustered,0.001,8,heuristic,65536,153648,1,1,65536,1,30906.2 +csv,combined,clustered,0.001,8,heuristic,0,0,0,0,0,0,577.2 +csv,independent,clustered,0.001,8,heuristic,640,28664,16,6,640,10,9662.2 +csv,unmasked,clustered,0.001,8,all_late,65536,153648,1,1,65536,1,35297.4 +csv,combined,clustered,0.001,8,all_late,0,0,0,0,0,0,514.4 +csv,independent,clustered,0.001,8,all_late,640,28664,16,6,640,10,10604.4 +csv,unmasked,clustered,0.001,8,all_early,65536,153648,1,1,65536,1,34891.0 +csv,combined,clustered,0.001,8,all_early,0,0,0,0,0,0,540.2 +csv,independent,clustered,0.001,8,all_early,640,28664,16,6,640,10,10492.7 +csv,unmasked,clustered,0.01,1,heuristic,65536,130448,1,1,65536,1,25185.8 +csv,combined,clustered,0.01,1,heuristic,704,31504,6,1,704,11,2180.4 +csv,independent,clustered,0.01,1,heuristic,704,31504,6,1,704,11,1864.5 +csv,unmasked,clustered,0.01,1,all_late,65536,130448,1,1,65536,1,17344.1 +csv,combined,clustered,0.01,1,all_late,704,31504,6,1,704,11,1939.2 +csv,independent,clustered,0.01,1,all_late,704,31504,6,1,704,11,1764.6 +csv,unmasked,clustered,0.01,1,all_early,65536,130448,1,1,65536,1,19001.3 +csv,combined,clustered,0.01,1,all_early,704,31504,6,1,704,11,1474.1 +csv,independent,clustered,0.01,1,all_early,704,31504,6,1,704,11,1447.6 +csv,unmasked,clustered,0.01,2,heuristic,65536,135832,2,1,65536,1,20051.5 +csv,combined,clustered,0.01,2,heuristic,0,0,0,0,0,0,394.4 +csv,independent,clustered,0.01,2,heuristic,1216,50136,13,2,1216,19,3348.5 +csv,unmasked,clustered,0.01,2,all_late,65536,135832,2,1,65536,1,19022.3 +csv,combined,clustered,0.01,2,all_late,0,0,0,0,0,0,389.3 +csv,independent,clustered,0.01,2,all_late,1216,50136,13,2,1216,19,3791.7 +csv,unmasked,clustered,0.01,2,all_early,65536,135832,2,1,65536,1,20488.1 +csv,combined,clustered,0.01,2,all_early,0,0,0,0,0,0,548.6 +csv,independent,clustered,0.01,2,all_early,1216,50136,13,2,1216,19,4070.1 +csv,unmasked,clustered,0.01,4,heuristic,65536,145968,4,1,65536,1,28818.4 +csv,combined,clustered,0.01,4,heuristic,0,0,0,0,0,0,411.0 +csv,independent,clustered,0.01,4,heuristic,2112,91200,24,4,2112,33,7869.9 +csv,unmasked,clustered,0.01,4,all_late,65536,145968,4,1,65536,1,28776.7 +csv,combined,clustered,0.01,4,all_late,0,0,0,0,0,0,539.2 +csv,independent,clustered,0.01,4,all_late,2112,91200,24,4,2112,33,7877.0 +csv,unmasked,clustered,0.01,4,all_early,65536,145968,4,1,65536,1,25623.6 +csv,combined,clustered,0.01,4,all_early,0,0,0,0,0,0,433.6 +csv,independent,clustered,0.01,4,all_early,2112,91200,24,4,2112,33,7578.7 +csv,unmasked,clustered,0.01,8,heuristic,65536,169416,8,1,65536,1,38129.1 +csv,combined,clustered,0.01,8,heuristic,0,0,0,0,0,0,845.8 +csv,independent,clustered,0.01,8,heuristic,4544,214248,51,8,4544,71,14683.2 +csv,unmasked,clustered,0.01,8,all_late,65536,169416,8,1,65536,1,38086.7 +csv,combined,clustered,0.01,8,all_late,0,0,0,0,0,0,1364.7 +csv,independent,clustered,0.01,8,all_late,4544,214248,51,8,4544,71,14503.7 +csv,unmasked,clustered,0.01,8,all_early,65536,169416,8,1,65536,1,31587.2 +csv,combined,clustered,0.01,8,all_early,0,0,0,0,0,0,889.4 +csv,independent,clustered,0.01,8,all_early,4544,214248,51,8,4544,71,13680.4 +csv,unmasked,clustered,0.1,1,heuristic,65536,159928,1,1,65536,1,27283.1 +csv,combined,clustered,0.1,1,heuristic,6528,153736,2,1,6528,93,4293.7 +csv,independent,clustered,0.1,1,heuristic,6528,153736,2,1,6528,93,3759.9 +csv,unmasked,clustered,0.1,1,all_late,65536,159928,1,1,65536,1,17586.7 +csv,combined,clustered,0.1,1,all_late,6528,153736,2,1,6528,93,3682.7 +csv,independent,clustered,0.1,1,all_late,6528,153736,2,1,6528,93,3564.8 +csv,unmasked,clustered,0.1,1,all_early,65536,159928,1,1,65536,1,18498.3 +csv,combined,clustered,0.1,1,all_early,6528,153736,2,1,6528,93,4616.4 +csv,independent,clustered,0.1,1,all_early,6528,153736,2,1,6528,93,4507.8 +csv,unmasked,clustered,0.1,2,heuristic,65536,194472,2,1,65536,1,20208.1 +csv,combined,clustered,0.1,2,heuristic,832,80512,10,1,832,13,2321.9 +csv,independent,clustered,0.1,2,heuristic,12800,308184,5,2,12800,183,8682.5 +csv,unmasked,clustered,0.1,2,all_late,65536,194472,2,1,65536,1,20015.5 +csv,combined,clustered,0.1,2,all_late,832,80512,10,1,832,13,2644.0 +csv,independent,clustered,0.1,2,all_late,12800,308184,5,2,12800,183,9135.9 +csv,unmasked,clustered,0.1,2,all_early,65536,194472,2,1,65536,1,21190.0 +csv,combined,clustered,0.1,2,all_early,832,80512,10,1,832,13,2326.8 +csv,independent,clustered,0.1,2,all_early,12800,308184,5,2,12800,183,8839.5 +csv,unmasked,clustered,0.1,4,heuristic,65536,263544,4,1,65536,1,24152.7 +csv,combined,clustered,0.1,4,heuristic,0,0,0,0,0,0,666.7 +csv,independent,clustered,0.1,4,heuristic,25344,619256,10,4,25344,361,21098.2 +csv,unmasked,clustered,0.1,4,all_late,65536,263544,4,1,65536,1,28168.5 +csv,combined,clustered,0.1,4,all_late,0,0,0,0,0,0,514.6 +csv,independent,clustered,0.1,4,all_late,25344,619256,10,4,25344,361,15613.6 +csv,unmasked,clustered,0.1,4,all_early,65536,263544,4,1,65536,1,26041.7 +csv,combined,clustered,0.1,4,all_early,0,0,0,0,0,0,398.1 +csv,independent,clustered,0.1,4,all_early,25344,619256,10,4,25344,361,17254.8 +csv,unmasked,clustered,0.1,8,heuristic,65536,406864,8,1,65536,1,30902.3 +csv,combined,clustered,0.1,8,heuristic,0,0,0,0,0,0,569.6 +csv,independent,clustered,0.1,8,heuristic,51456,1250448,20,8,51456,725,32886.7 +csv,unmasked,clustered,0.1,8,all_late,65536,406864,8,1,65536,1,31709.7 +csv,combined,clustered,0.1,8,all_late,0,0,0,0,0,0,572.3 +csv,independent,clustered,0.1,8,all_late,51456,1250448,20,8,51456,725,31697.9 +csv,unmasked,clustered,0.1,8,all_early,65536,406864,8,1,65536,1,32401.4 +csv,combined,clustered,0.1,8,all_early,0,0,0,0,0,0,507.0 +csv,independent,clustered,0.1,8,all_early,51456,1250448,20,8,51456,725,27429.8 +csv,unmasked,clustered,0.5,1,heuristic,65536,1180776,1,1,65536,1,17634.3 +csv,combined,clustered,0.5,1,heuristic,32512,1086016,21,1,32512,249,13254.5 +csv,independent,clustered,0.5,1,heuristic,32512,1086016,21,1,32512,249,14353.7 +csv,unmasked,clustered,0.5,1,all_late,65536,1180776,1,1,65536,1,19928.9 +csv,combined,clustered,0.5,1,all_late,32512,1086016,21,1,32512,249,13746.2 +csv,independent,clustered,0.5,1,all_late,32512,1086016,21,1,32512,249,19965.6 +csv,unmasked,clustered,0.5,1,all_early,65536,1180776,1,1,65536,1,19783.0 +csv,combined,clustered,0.5,1,all_early,32512,1086016,21,1,32512,249,15959.6 +csv,independent,clustered,0.5,1,all_early,32512,1086016,21,1,32512,249,12521.1 +csv,unmasked,clustered,0.5,2,heuristic,65536,1299824,1,1,65536,1,19272.8 +csv,combined,clustered,0.5,2,heuristic,15232,915328,62,1,15232,179,7626.9 +csv,independent,clustered,0.5,2,heuristic,64640,1328816,23,2,64640,509,23061.3 +csv,unmasked,clustered,0.5,2,all_late,65536,1299824,1,1,65536,1,19268.4 +csv,combined,clustered,0.5,2,all_late,15232,915328,62,1,15232,179,9204.2 +csv,independent,clustered,0.5,2,all_late,64640,1328816,23,2,64640,509,32190.6 +csv,unmasked,clustered,0.5,2,all_early,65536,1299824,1,1,65536,1,19595.1 +csv,combined,clustered,0.5,2,all_early,15232,915328,62,1,15232,179,7910.0 +csv,independent,clustered,0.5,2,all_early,64640,1328816,23,2,64640,509,23795.7 +csv,unmasked,clustered,0.5,4,heuristic,65536,2474528,3,1,65536,1,24328.3 +csv,combined,clustered,0.5,4,heuristic,3328,739232,92,1,3328,52,6264.3 +csv,independent,clustered,0.5,4,heuristic,128896,2685664,42,4,128896,1032,49197.1 +csv,unmasked,clustered,0.5,4,all_late,65536,2474528,3,1,65536,1,30566.8 +csv,combined,clustered,0.5,4,all_late,3328,739232,92,1,3328,52,5459.1 +csv,independent,clustered,0.5,4,all_late,128896,2685664,42,4,128896,1032,56672.0 +csv,unmasked,clustered,0.5,4,all_early,65536,2474528,3,1,65536,1,24758.5 +csv,combined,clustered,0.5,4,all_early,3328,739232,92,1,3328,52,5246.5 +csv,independent,clustered,0.5,4,all_early,128896,2685664,42,4,128896,1032,47817.6 +csv,unmasked,clustered,0.5,8,heuristic,65536,6701944,3,1,65536,1,30654.2 +csv,combined,clustered,0.5,8,heuristic,192,92312,27,1,192,3,2262.6 +csv,independent,clustered,0.5,8,heuristic,258368,7133064,112,8,258368,2083,101601.7 +csv,unmasked,clustered,0.5,8,all_late,65536,6701944,3,1,65536,1,33449.3 +csv,combined,clustered,0.5,8,all_late,192,92312,27,1,192,3,2754.0 +csv,independent,clustered,0.5,8,all_late,258368,7133064,112,8,258368,2083,106046.7 +csv,unmasked,clustered,0.5,8,all_early,65536,6701944,3,1,65536,1,31704.7 +csv,combined,clustered,0.5,8,all_early,192,92312,27,1,192,3,2803.4 +csv,independent,clustered,0.5,8,all_early,258368,7133064,112,8,258368,2083,93941.8 +csv,unmasked,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,18408.7 +csv,combined,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,21556.2 +csv,independent,clustered,1,1,heuristic,65536,1175680,1,1,65536,1,23025.2 +csv,unmasked,clustered,1,1,all_late,65536,1175680,1,1,65536,1,17484.8 +csv,combined,clustered,1,1,all_late,65536,1175680,1,1,65536,1,22233.8 +csv,independent,clustered,1,1,all_late,65536,1175680,1,1,65536,1,22855.6 +csv,unmasked,clustered,1,1,all_early,65536,1175680,1,1,65536,1,23621.5 +csv,combined,clustered,1,1,all_early,65536,1175680,1,1,65536,1,21541.2 +csv,independent,clustered,1,1,all_early,65536,1175680,1,1,65536,1,21110.0 +csv,unmasked,clustered,1,2,heuristic,65536,2227328,1,1,65536,1,19124.9 +csv,combined,clustered,1,2,heuristic,65536,2227328,1,1,65536,1,22927.6 +csv,independent,clustered,1,2,heuristic,131072,2350336,3,2,131072,2,42014.5 +csv,unmasked,clustered,1,2,all_late,65536,2227328,1,1,65536,1,18549.0 +csv,combined,clustered,1,2,all_late,65536,2227328,1,1,65536,1,23883.7 +csv,independent,clustered,1,2,all_late,131072,2350336,3,2,131072,2,47030.9 +csv,unmasked,clustered,1,2,all_early,65536,2227328,1,1,65536,1,19279.8 +csv,combined,clustered,1,2,all_early,65536,2227328,1,1,65536,1,24006.4 +csv,independent,clustered,1,2,all_early,131072,2350336,3,2,131072,2,46083.4 +csv,unmasked,clustered,1,4,heuristic,65536,4330624,1,1,65536,1,24521.3 +csv,combined,clustered,1,4,heuristic,65536,4330624,1,1,65536,1,30269.0 +csv,independent,clustered,1,4,heuristic,262144,4699648,7,4,262144,4,87551.4 +csv,unmasked,clustered,1,4,all_late,65536,4330624,1,1,65536,1,22160.0 +csv,combined,clustered,1,4,all_late,65536,4330624,1,1,65536,1,27930.1 +csv,independent,clustered,1,4,all_late,262144,4699648,7,4,262144,4,91928.8 +csv,unmasked,clustered,1,4,all_early,65536,4330624,1,1,65536,1,23885.6 +csv,combined,clustered,1,4,all_early,65536,4330624,1,1,65536,1,27318.1 +csv,independent,clustered,1,4,all_early,262144,4699648,7,4,262144,4,84486.1 +csv,unmasked,clustered,1,8,heuristic,65536,8535168,3,2,65536,1,32631.3 +csv,combined,clustered,1,8,heuristic,65536,8535168,3,2,65536,1,35081.6 +csv,independent,clustered,1,8,heuristic,524288,9398272,15,8,524288,8,179173.7 +csv,unmasked,clustered,1,8,all_late,65536,8535168,3,2,65536,1,26985.3 +csv,combined,clustered,1,8,all_late,65536,8535168,3,2,65536,1,32387.4 +csv,independent,clustered,1,8,all_late,524288,9398272,15,8,524288,8,176398.4 +csv,unmasked,clustered,1,8,all_early,65536,8535168,3,2,65536,1,27670.0 +csv,combined,clustered,1,8,all_early,65536,8535168,3,2,65536,1,35463.1 +csv,independent,clustered,1,8,all_early,524288,9398272,15,8,524288,8,186553.0 ``` diff --git a/.claude/plans/d-holo-h14c-thought-first-v1.md b/.claude/plans/d-holo-h14c-thought-first-v1.md index 9d3600ed5..80081483b 100644 --- a/.claude/plans/d-holo-h14c-thought-first-v1.md +++ b/.claude/plans/d-holo-h14c-thought-first-v1.md @@ -324,7 +324,8 @@ block (CSV inside the entry) and the console output to the session scratchpad. **Run record.** `tier: v4 (avx512f)` printed by both probes (Intel Xeon @ 2.80 GHz, 4 vCPUs, avx512f/bw/cd/dq/vl/vnni; `MemTotal 16,479,424 kB`); `rustc 1.99.0 -(b940084d7 2026-09-28)`; `lance 13.0.0` (probe crate's own lockfile). In-memory +(b940084d7 2026-09-28)`; `lance 13.0.0` (resolved at build time and printed by the probe; the +repository tracks no lockfile). In-memory probe: `cargo run --release -p lance-graph-mask-risc --example holo_thought_first_probe` (sections A, B, C, thought and spatial axes) and `… -- memory` (memory grid, one child process per cell); 7 batches of 8,192 @@ -485,46 +486,46 @@ cache), not a physical disk count. | pattern | dirty | k | style | unmasked bytes | independent bytes (ratio) | rows scanned indep / unmasked | combined rows | combined bytes (ratio) | unmasked µs | combined µs | independent µs | |---|---|---|---|---|---|---|---|---|---|---|---| -| uniform | 0.1 % | 1 | heuristic | 127296 | 97424 (0.77) | 46 / 65536 | 46 | 97424 (0.77) | 20361 | 1903 | 1732 | -| uniform | 0.1 % | 2 | heuristic | 131560 | 202952 (1.54) | 112 / 65536 | 1 | 6536 (0.05) | 19577 | 1441 | 3531 | -| uniform | 0.1 % | 4 | heuristic | 140808 | 419424 (2.98) | 245 / 65536 | 0 | 0 (0.00) | 44787 | 459 | 6882 | -| uniform | 0.1 % | 8 | heuristic | 159736 | 849024 (5.32) | 531 / 65536 | 0 | 0 (0.00) | 50480 | 690 | 14724 | -| uniform | 1 % | 1 | heuristic | 136160 | 136160 (1.00) | 692 / 65536 | 692 | 136160 (1.00) | 17419 | 2238 | 2059 | -| uniform | 1 % | 2 | heuristic | 147720 | 271752 (1.84) | 1354 / 65536 | 9 | 30920 (0.21) | 18436 | 2420 | 7810 | -| uniform | 1 % | 4 | heuristic | 170624 | 542720 (3.18) | 2655 / 65536 | 0 | 0 (0.00) | 28349 | 588 | 11766 | -| uniform | 1 % | 8 | heuristic | 217040 | 1085264 (5.00) | 5304 / 65536 | 0 | 0 (0.00) | 43980 | 579 | 23244 | -| uniform | 10 % | 1 | heuristic | 195416 | 195416 (1.00) | 6606 / 65536 | 6606 | 195416 (1.00) | 22045 | 6994 | 7035 | -| uniform | 10 % | 2 | heuristic | 266584 | 390616 (1.47) | 13194 / 65536 | 679 | 266584 (1.00) | 21164 | 3198 | 14780 | -| uniform | 10 % | 4 | heuristic | 409560 | 781656 (1.91) | 26435 / 65536 | 8 | 143320 (0.35) | 26194 | 2735 | 28000 | -| uniform | 10 % | 8 | heuristic | 692016 | 1560240 (2.25) | 52513 / 65536 | 0 | 0 (0.00) | 50365 | 529 | 64182 | -| uniform | 50 % | 1 | heuristic | 1208448 | 1208448 (1.00) | 33120 / 65536 | 33120 | 1208448 (1.00) | 18861 | 20882 | 22606 | -| uniform | 50 % | 2 | heuristic | 2292864 | 2415872 (1.05) | 65891 / 65536 | 16591 | 2292864 (1.00) | 21271 | 18150 | 43608 | -| uniform | 50 % | 4 | heuristic | 2541824 | 2912640 (1.15) | 131294 / 65536 | 4074 | 2541824 (1.00) | 29479 | 11880 | 79249 | -| uniform | 50 % | 8 | heuristic | 4958336 | 5824256 (1.17) | 261893 / 65536 | 247 | 3195520 (0.64) | 39020 | 11242 | 167085 | -| uniform | 100 % | 1 | heuristic | 1175680 | 1175680 (1.00) | 65536 / 65536 | 65536 | 1175680 (1.00) | 17436 | 21706 | 21129 | -| uniform | 100 % | 2 | heuristic | 2227328 | 2350336 (1.06) | 131072 / 65536 | 65536 | 2227328 (1.00) | 20555 | 30819 | 44391 | -| uniform | 100 % | 4 | heuristic | 4330624 | 4699648 (1.09) | 262144 / 65536 | 65536 | 4330624 (1.00) | 22931 | 27403 | 87673 | -| uniform | 100 % | 8 | heuristic | 8535168 | 9398272 (1.10) | 524288 / 65536 | 65536 | 8535168 (1.00) | 33334 | 38369 | 192390 | -| clustered | 0.1 % | 1 | heuristic | 127744 | 3000 (0.02) | 64 / 65536 | 64 | 3000 (0.02) | 17289 | 1350 | 1394 | -| clustered | 0.1 % | 2 | heuristic | 132552 | 6008 (0.05) | 128 / 65536 | 0 | 0 (0.00) | 18579 | 349 | 2546 | -| clustered | 0.1 % | 4 | heuristic | 143048 | 14184 (0.10) | 320 / 65536 | 0 | 0 (0.00) | 21828 | 440 | 4593 | -| clustered | 0.1 % | 8 | heuristic | 153648 | 28664 (0.19) | 640 / 65536 | 0 | 0 (0.00) | 28765 | 546 | 10190 | -| clustered | 1 % | 1 | heuristic | 130448 | 31504 (0.24) | 704 / 65536 | 704 | 31504 (0.24) | 16859 | 1812 | 1488 | -| clustered | 1 % | 2 | heuristic | 135832 | 50136 (0.37) | 1216 / 65536 | 0 | 0 (0.00) | 18830 | 343 | 2957 | -| clustered | 1 % | 4 | heuristic | 145968 | 91200 (0.62) | 2112 / 65536 | 0 | 0 (0.00) | 31447 | 412 | 6281 | -| clustered | 1 % | 8 | heuristic | 169416 | 214248 (1.26) | 4544 / 65536 | 0 | 0 (0.00) | 28629 | 498 | 14205 | -| clustered | 10 % | 1 | heuristic | 159928 | 153736 (0.96) | 6528 / 65536 | 6528 | 153736 (0.96) | 17550 | 3528 | 3605 | -| clustered | 10 % | 2 | heuristic | 194472 | 308184 (1.58) | 12800 / 65536 | 832 | 80512 (0.41) | 18680 | 1934 | 6508 | -| clustered | 10 % | 4 | heuristic | 263544 | 619256 (2.35) | 25344 / 65536 | 0 | 0 (0.00) | 23435 | 425 | 13853 | -| clustered | 10 % | 8 | heuristic | 406864 | 1250448 (3.07) | 51456 / 65536 | 0 | 0 (0.00) | 29721 | 532 | 31067 | -| clustered | 50 % | 1 | heuristic | 1180776 | 1086016 (0.92) | 32512 / 65536 | 32512 | 1086016 (0.92) | 17714 | 13810 | 14064 | -| clustered | 50 % | 2 | heuristic | 1299824 | 1328816 (1.02) | 64640 / 65536 | 15232 | 915328 (0.70) | 21886 | 10748 | 27227 | -| clustered | 50 % | 4 | heuristic | 2474528 | 2685664 (1.09) | 128896 / 65536 | 3328 | 739232 (0.30) | 25104 | 6432 | 55687 | -| clustered | 50 % | 8 | heuristic | 6701944 | 7133064 (1.06) | 258368 / 65536 | 192 | 92312 (0.01) | 33188 | 2556 | 106485 | -| clustered | 100 % | 1 | heuristic | 1175680 | 1175680 (1.00) | 65536 / 65536 | 65536 | 1175680 (1.00) | 17438 | 22304 | 23203 | -| clustered | 100 % | 2 | heuristic | 2227328 | 2350336 (1.06) | 131072 / 65536 | 65536 | 2227328 (1.00) | 18155 | 23203 | 43737 | -| clustered | 100 % | 4 | heuristic | 4330624 | 4699648 (1.09) | 262144 / 65536 | 65536 | 4330624 (1.00) | 23527 | 29553 | 96698 | -| clustered | 100 % | 8 | heuristic | 8535168 | 9398272 (1.10) | 524288 / 65536 | 65536 | 8535168 (1.00) | 30948 | 39615 | 183068 | +| uniform | 0.1 % | 1 | heuristic | 127296 | 97424 (0.77) | 46 / 65536 | 46 | 97424 (0.77) | 24016 | 1544 | 1252 | +| uniform | 0.1 % | 2 | heuristic | 131560 | 202952 (1.54) | 112 / 65536 | 1 | 6536 (0.05) | 21806 | 1363 | 3203 | +| uniform | 0.1 % | 4 | heuristic | 140808 | 419424 (2.98) | 245 / 65536 | 0 | 0 (0.00) | 30442 | 406 | 6820 | +| uniform | 0.1 % | 8 | heuristic | 159736 | 849024 (5.32) | 531 / 65536 | 0 | 0 (0.00) | 42240 | 491 | 12051 | +| uniform | 1 % | 1 | heuristic | 136160 | 136160 (1.00) | 692 / 65536 | 692 | 136160 (1.00) | 18135 | 2640 | 2579 | +| uniform | 1 % | 2 | heuristic | 147720 | 271752 (1.84) | 1354 / 65536 | 9 | 30920 (0.21) | 19547 | 1531 | 4534 | +| uniform | 1 % | 4 | heuristic | 170624 | 542720 (3.18) | 2655 / 65536 | 0 | 0 (0.00) | 24855 | 398 | 9633 | +| uniform | 1 % | 8 | heuristic | 217040 | 1085264 (5.00) | 5304 / 65536 | 0 | 0 (0.00) | 30113 | 524 | 16802 | +| uniform | 10 % | 1 | heuristic | 195416 | 195416 (1.00) | 6606 / 65536 | 6606 | 195416 (1.00) | 18726 | 8030 | 8362 | +| uniform | 10 % | 2 | heuristic | 266584 | 390616 (1.47) | 13194 / 65536 | 679 | 266584 (1.00) | 21610 | 3642 | 16969 | +| uniform | 10 % | 4 | heuristic | 409560 | 781656 (1.91) | 26435 / 65536 | 8 | 143320 (0.35) | 24118 | 2791 | 34299 | +| uniform | 10 % | 8 | heuristic | 692016 | 1560240 (2.25) | 52513 / 65536 | 0 | 0 (0.00) | 46024 | 542 | 60455 | +| uniform | 50 % | 1 | heuristic | 1208448 | 1208448 (1.00) | 33120 / 65536 | 33120 | 1208448 (1.00) | 18422 | 19593 | 20913 | +| uniform | 50 % | 2 | heuristic | 2292864 | 2415872 (1.05) | 65891 / 65536 | 16591 | 2292864 (1.00) | 29535 | 19743 | 42360 | +| uniform | 50 % | 4 | heuristic | 2541824 | 2912640 (1.15) | 131294 / 65536 | 4074 | 2541824 (1.00) | 27553 | 12331 | 78100 | +| uniform | 50 % | 8 | heuristic | 4958336 | 5824256 (1.17) | 261893 / 65536 | 247 | 3195520 (0.64) | 38960 | 11204 | 183889 | +| uniform | 100 % | 1 | heuristic | 1175680 | 1175680 (1.00) | 65536 / 65536 | 65536 | 1175680 (1.00) | 26148 | 24902 | 23463 | +| uniform | 100 % | 2 | heuristic | 2227328 | 2350336 (1.06) | 131072 / 65536 | 65536 | 2227328 (1.00) | 20804 | 26007 | 59764 | +| uniform | 100 % | 4 | heuristic | 4330624 | 4699648 (1.09) | 262144 / 65536 | 65536 | 4330624 (1.00) | 27932 | 31766 | 99231 | +| uniform | 100 % | 8 | heuristic | 8535168 | 9398272 (1.10) | 524288 / 65536 | 65536 | 8535168 (1.00) | 35396 | 35899 | 198529 | +| clustered | 0.1 % | 1 | heuristic | 127744 | 3000 (0.02) | 64 / 65536 | 64 | 3000 (0.02) | 20594 | 1426 | 1120 | +| clustered | 0.1 % | 2 | heuristic | 132552 | 6008 (0.05) | 128 / 65536 | 0 | 0 (0.00) | 21548 | 411 | 2328 | +| clustered | 0.1 % | 4 | heuristic | 143048 | 14184 (0.10) | 320 / 65536 | 0 | 0 (0.00) | 25836 | 399 | 4418 | +| clustered | 0.1 % | 8 | heuristic | 153648 | 28664 (0.19) | 640 / 65536 | 0 | 0 (0.00) | 30906 | 577 | 9662 | +| clustered | 1 % | 1 | heuristic | 130448 | 31504 (0.24) | 704 / 65536 | 704 | 31504 (0.24) | 25186 | 2180 | 1864 | +| clustered | 1 % | 2 | heuristic | 135832 | 50136 (0.37) | 1216 / 65536 | 0 | 0 (0.00) | 20052 | 394 | 3348 | +| clustered | 1 % | 4 | heuristic | 145968 | 91200 (0.62) | 2112 / 65536 | 0 | 0 (0.00) | 28818 | 411 | 7870 | +| clustered | 1 % | 8 | heuristic | 169416 | 214248 (1.26) | 4544 / 65536 | 0 | 0 (0.00) | 38129 | 846 | 14683 | +| clustered | 10 % | 1 | heuristic | 159928 | 153736 (0.96) | 6528 / 65536 | 6528 | 153736 (0.96) | 27283 | 4294 | 3760 | +| clustered | 10 % | 2 | heuristic | 194472 | 308184 (1.58) | 12800 / 65536 | 832 | 80512 (0.41) | 20208 | 2322 | 8682 | +| clustered | 10 % | 4 | heuristic | 263544 | 619256 (2.35) | 25344 / 65536 | 0 | 0 (0.00) | 24153 | 667 | 21098 | +| clustered | 10 % | 8 | heuristic | 406864 | 1250448 (3.07) | 51456 / 65536 | 0 | 0 (0.00) | 30902 | 570 | 32887 | +| clustered | 50 % | 1 | heuristic | 1180776 | 1086016 (0.92) | 32512 / 65536 | 32512 | 1086016 (0.92) | 17634 | 13254 | 14354 | +| clustered | 50 % | 2 | heuristic | 1299824 | 1328816 (1.02) | 64640 / 65536 | 15232 | 915328 (0.70) | 19273 | 7627 | 23061 | +| clustered | 50 % | 4 | heuristic | 2474528 | 2685664 (1.09) | 128896 / 65536 | 3328 | 739232 (0.30) | 24328 | 6264 | 49197 | +| clustered | 50 % | 8 | heuristic | 6701944 | 7133064 (1.06) | 258368 / 65536 | 192 | 92312 (0.01) | 30654 | 2263 | 101602 | +| clustered | 100 % | 1 | heuristic | 1175680 | 1175680 (1.00) | 65536 / 65536 | 65536 | 1175680 (1.00) | 18409 | 21556 | 23025 | +| clustered | 100 % | 2 | heuristic | 2227328 | 2350336 (1.06) | 131072 / 65536 | 65536 | 2227328 (1.00) | 19125 | 22928 | 42014 | +| clustered | 100 % | 4 | heuristic | 4330624 | 4699648 (1.09) | 262144 / 65536 | 65536 | 4330624 (1.00) | 24521 | 30269 | 87551 | +| clustered | 100 % | 8 | heuristic | 8535168 | 9398272 (1.10) | 524288 / 65536 | 65536 | 8535168 (1.00) | 32631 | 35082 | 179174 | **Prediction: both halves hold.** At 1 % uniform, k = 1: masked bytes = unmasked bytes (136,160; ratio 1.00) while rows scanned fall to 692 of 65,536. At 1 % @@ -538,8 +539,18 @@ clustered, k = 1: ratio 0.24 (≤ 0.5). At 0.1 % uniform the ratio is 0.77. uniform low density (1.5–5.3×). - The combined mask (every requested lane present) is the joint population, ≈ dᵏ for independent lanes: one row at 0.1 %, k = 2. -- Wall time: masked reads of small populations take 0.3–2.4 ms against - 17–55 ms unmasked; at 100 % the masked read is slower (22 vs 17 ms, k = 1). +- Wall time (heuristic style; times from the re-run after review, see below): + combined masked reads at ≤ 1 % density take 0.39–2.6 ms against 17.6–46 ms + unmasked. At 100 %, k = 1, the two are within run-to-run noise (uniform + 24.9 vs 26.1 ms, clustered 21.6 vs 18.4 ms); no ordering is claimed there. +- Re-run after review (#1573): the first run built each lane's mask inside + the timed loop for the independent strategy, while the combined strategy + built its mask before the timer. The masks are now built before the timer + for both. All three timing columns above come from the re-run; bytes, IOPS, + requests and rows scanned were identical in both runs (360 of 360 rows). + Timings moved by up to about 40 % between the two runs even for the + unmasked baseline, which the defect did not touch, so differences below + that size are not read as results. ### Coordinate identity (H14c-5)