diff --git a/docs/benchmark-chart-sensitivity-audit.md b/docs/benchmark-chart-sensitivity-audit.md new file mode 100644 index 00000000000..28003f8ebbc --- /dev/null +++ b/docs/benchmark-chart-sensitivity-audit.md @@ -0,0 +1,135 @@ +# Benchmark chart sensitivity audit, 2026-11-07 + +The [extended history campaign](benchmark-extended-history-campaign.md) implements additional +workloads and qualifies them against 130 historical production builds on drogon. + +The standard landscape does not provide a sufficient view of XFF's optimization progress. +Its arithmetic reproduces the retained measurements, and its browser renderer responds to +changed timings. However, its workload and executable coverage exclude several large measured +improvements, and it does not show a controlled XFF-before/after comparison. A similar-looking +surface cannot establish that the optimizations were ineffective. + +## Evidence and boundaries + +Source: `ae8c5af3eb11dc8571f11db9b307b0db948f78c6` (#1130). +Pages: `153d58627f2132b838a091ffcfdb30dd49571b8b`. +The live `/xff/benchmarks/catalog.json` exactly matched this snapshot, including its SHA-256. +The catalog contains 528 entries; the browser's duplicate selection leaves 490 reports across +five datasets. See the [machine-readable results](benchmarks/chart-sensitivity-audit-20261107.json). + +The current-performance assessment excludes local Linux v2 at the user's direction because it +has not been measured recently. Its retained arithmetic checks remain historical evidence only; +its age and clipping statistics are not explanations for the current CI charts. + +An independent calculation selects each participant's recorded fastest samples and recomputes +`100 * (1 - XFF/reference)` and `-log10(XFF/reference)`. It checks the decoded packed figures +against raw records by task, tree, worker count, file count and reference tool, across all three +orders, both metrics and every available worker pair. All 3,178,656 plotted values match. +Catalog revisions and available catalog binary hashes also match their underlying reports. + +A headless Chromium control serves the retained site and its published JavaScript locally. +Selecting the previous and latest Linux versions loads different commits and values. Picked +surface values match the selected figures. A separately generated synthetic report halves every +XFF elapsed sample while preserving reference samples. All 468 default figure values change by +the expected formula `new_height = 50 + old_height / 2`, and the rendered canvas changes. +The synthetic data is an explicitly labelled sensitivity control; it is never published or +substituted for a historical measurement. + +This does not independently verify every historical executable, its compiler, its fixture oracle, +or the cause of historical timing variation. The claimed optimization results below come from +their existing qualification reports; those experiments were not rerun in this audit. + +## Published coverage is incomplete for the intended question + +The actively updated CI datasets contain 138 selected revisions per platform through #1122, +November 6. They do not retain every merge. The workload coverage and hosted-run comparisons +below assess these CI datasets; the older local datasets remain in the historical inventory. + +The chart measures the lean `//xff/cli:xff` production executable. It does not measure the +extended `xff_full` executable or exercise its archive features. Its command policy fixes +`--no-config --no-pager --color=never --sort=none --exact --case=sensitive --gitignore=off +--hidden`, uses the relative root `.`, and emits NUL-delimited paths with `-print0`. + +There are seven XFF tasks with reference comparisons: file discovery, `*.txt` names, two exact +content searches, and three ordered-subsequence fuzzy path filters. These yield nine task/reference +pairs. `files-safe` has XFF measurements but no reference, so `relative_results()` omits it from +the landscape. The three precomputed fuzzy-list tasks measure fzf alone. Fuzzy path filtering +does not exercise content-similarity scoring. + +Specific mismatches between demonstrated gains and the chart: + +| Change | Existing qualification evidence | Why the standard chart misses the gain | +| :------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------- | +| #1105 archive directory ranges | Complete 100k-member TAR traversals fall from about 9-14 seconds to 94-187 milliseconds across both hosts | No archives; lean binary | +| #1116 empty CCTZ fragments | macOS timestamp-bearing metadata commands improve about 92% | No formatted timestamps; output is `-print0` | +| #1091 uniform native case | Linux broad 100k-file name search falls from about 129 ms to 44 ms with one worker | Every chart command passes `--exact`, bypassing native-case lookup | +| #1090 names-only listing paths | Broad absolute-root listings improve about 9-14%; short relative-root controls are mostly neutral on Mac and 1-2% slower on Linux | Chart always uses the short relative root `.` | +| #1094 compact traversal metadata | Broad native listings improve about 5-6% on Mac and 8-9% on Linux; memory improves too | This path is exercised, but the chart shows only competitor-relative elapsed time, with no uncertainty or memory history | + +Sources: [archive ranges](benchmarks/archive-directory-range-20261105.md), +[CCTZ](benchmarks/cctz-empty-format-20261105.md), +[native case](benchmarks/uniform-native-case-20261104.md), +[listing paths](benchmarks/native-name-paths-20261104.md), and +[compact metadata](benchmarks/compact-traversal-metadata-20261104.md). +These are workload-specific results, not additive percentages or universal binary speedups. + +## Movement exists, but the chart is a poor progress measure + +For Linux broad/100k/one-worker `files` versus rg, the published #1093 report records XFF at +63.655 ms and rg at 47.570 ms; #1094 records 59.888 ms and 48.282 ms. The chart value moves +from -33.814% to -24.037%, exactly as the raw data requires. This is an example of actual chart +movement, not a paired causal estimate of #1094: these are different hosted runs. + +Six reports (#1102, #1103, #1104, #1105, #1117 and #1107) record the same Linux executable +SHA-256 `09c997ab01d2d7dfe916bf1cced7b54757c6b6b25f8d2a9743812e9db23efb51` and the same +OS release. Yet that same listing cell ranges from 57.341 to 64.831 ms, and its XFF/rg ratio +from 1.2186 to 1.2930. This is observed variation across hosted runs of an unchanged binary; +it cannot be explained by an XFF code improvement between those measurements. It does not +identify the cause of that variation or estimate uncertainty for every workload. + +The surface shows XFF/reference in each run, not XFF/new versus XFF/old. Reference normalization +adds a corrected time to the hover details; it intentionally does not change the ratio or surface. +Thus changing the Timings selector does not change geometry. Hosted sample aggregation pools +three hosts' samples and selects fastest samples separately per participant; the selected XFF +and reference host contributions can differ. Neither that estimator nor a reference ratio is a +substitute for an interleaved old/new experiment with uncertainty. + +The latest CI default views have no clipped points, so clipping does not explain their apparent +lack of movement. As a general display constraint, the default percentage range is +/-100 with +capping: any XFF/reference ratio >=2 reaches the same bottom boundary, and percentage gains +approach +100 asymptotically. Logarithmic scale can expose differences if its selected range +includes them. Auto range rescales each report and is unsuitable for judging uniform changes by +shape alone. These general constraints are not evidence of clipping in the current CI views. + +Recent published Similarity order is shared within compatible history after #1093; Average order +still changes with each report. A shared task order helps track cells but does not supply missing +workloads, new measurements or a historical baseline. + +## Changes needed before treating this as an optimization dashboard + +1. Show each dataset's latest measured source and its distance behind current main prominently. + Give the standard landscape an explicit workload scope and identify the measured binary. +2. Retain a permanent, versioned suite of production commands covering ordinary native-case + and exact-case discovery, relative and absolute roots, metadata/time output, summaries, + content search, similarity, comparisons, and full-binary archive traversal. Keep the existing + competitor suite as one view; do not silently change its historical workload definition. +3. Measure selected old/new production binaries interleaved on the same host and fixture, with + an identical-binary control. Publish absolute elapsed time, first-result latency, CPU and memory, + paired changes and uncertainty. Preserve worker budgets, raw samples and executable identities. +4. Display XFF-only workloads even when no competing tool implements the same operation. Add an + XFF-before/after view with fixed task positions and scales; show unavailable cells and clipping + counts. Keep competitor-relative values and reference corrections explicitly labelled. +5. Link each claimed speedup to its exercised workload and add that workload to continuing + regression coverage. Qualify a small representative panel before expanding historical runs. + +No new benchmark campaign is needed to establish the coverage and presentation defects above. +Repeating the current matrix alone would continue to miss archive, timestamp and native-case gains. + +## Retained audit artifacts + +The local evidence directory is `/private/tmp/xff-chart-evidence-20261107/`: +the extracted Pages snapshot, live catalog, selected records, independent `audit.py`, complete +`audit-summary.json`, per-cell `cells.csv`, `browser-check.mjs`, browser results and original versus +synthetic screenshots. Their hashes and representative raw-derived rows are in the linked JSON. +Browser controls used the existing installed Playwright/Chromium; no production files or published +measurements were changed. The temporary server and browser were closed after verification. diff --git a/docs/benchmark-correctness-audit.md b/docs/benchmark-correctness-audit.md index b03f336aca8..defa31a84b7 100644 --- a/docs/benchmark-correctness-audit.md +++ b/docs/benchmark-correctness-audit.md @@ -1,5 +1,12 @@ # Benchmark correctness audit and native investigation +The [2026-11-07 chart sensitivity audit](benchmark-chart-sensitivity-audit.md) revisits whether +the published landscape can demonstrate optimization progress. Its raw-to-figure arithmetic and +browser sensitivity checks pass, but it identifies workloads that bypass major optimized paths, +omitted XFF-only tasks, and limits of competitor-relative presentation in the current CI charts. +The current assessment excludes the old local Linux v2 dataset. +The earlier consistency checks below do not establish that the benchmark covers those improvements. + ## Scope and status Implementation and native-session handoff: [PR #990](https://github.com/mboworks/xff/pull/990), diff --git a/docs/benchmark-extended-history-campaign.md b/docs/benchmark-extended-history-campaign.md new file mode 100644 index 00000000000..9cf393f59e7 --- /dev/null +++ b/docs/benchmark-extended-history-campaign.md @@ -0,0 +1,245 @@ +# Extended benchmark history qualification + +This campaign qualifies additional CLI workloads against the last 130 merged PRs at +`ae8c5af3eb11dc8571f11db9b307b0db948f78c6` (PR #1130). Its oldest revision is +`21c7f3656b005b23113d936c1cd2ca0fd2221ab2` (PR #977). The manifest selects first-parent +commits with PR numbers; PR numbers are not a contiguous range. +The [frozen revision manifest](benchmarks/extended-history-revisions-20261107.json) is retained +with the implementation. + +It follows the [chart sensitivity audit](benchmark-chart-sensitivity-audit.md). These workloads +have their own recipe, `extended-production-v1`, and must remain a separate dataset from core +measurements. They use the existing 3D visualization framework. The stale local Linux v2 dataset +is outside this investigation. + +## Workloads fixed before collecting timings + +| Task | Operation | Equivalent traditional tool | Reason for inclusion | +| :-------------- | :--------------------------------------------------------- | :-------------------------- | :------------------------------------------------- | +| `files-exact` | List regular files with NUL termination | GNU find | Simple traversal control | +| `name-native` | Native-case `*.txt` match under an absolute root | GNU find | Native-case discovery and absolute-root work | +| `metadata-time` | Type, name and size filters; print path, size and UTC date | GNU find | Metadata and timestamp formatting | +| `content-regex` | Match a status regex in text files | ripgrep | Traversal, filename filtering and content matching | +| `archive-tar` | List matching regular-file members in a TAR | GNU tar | Archive indexing and virtual directory traversal | + +Each task has broad/deep fixtures and one/three allowed CPUs. Native tasks use +100, 10,000 and 100,000 files; archives use 100, 1,000 and 10,000 members: 60 cells per revision, +7,800 historical cells in total. Missing sizes remain missing in the renderer. + +Fixtures contain deterministic ASCII names and text, fixed UTC modification times and modes, +matching and nonmatching files, and 256-byte/8-KiB contents. Archive fixtures contain regular +members without explicit directory entries. Fixture contents and metadata are verified before +and after collection. Native fixtures require Linux case-sensitive tmpfs; this qualification +does not establish the same case semantics on a macOS filesystem. + +Drogon runs this campaign in a KVM guest. The guest reports an AMD Ryzen 9 9950X CPU model and +ten cores; the measurement affinity uses guest CPUs `0`, `1`, and `2`, selected from distinct +core IDs reported by Linux. This does not establish how the host pins those virtual CPUs to +physical cores. The guest kernel is `7.0.0-38-generic`, with glibc 2.43. The independently read +virtualization/DMI details are retained in `machine-environment.json` beside the campaign. + +The TAR reference transforms displayed names to the same `fixture.tar/member` spelling as XFF. +Native references use identical roots and output delimiters. Every invocation must succeed +without diagnostics and produce the exact expected multiset of records. Duplicate, missing or +extra records invalidate the invocation. Expected outputs come from the fixture recipe, rather +than another measured tool's output. + +## Build and measurement contract + +- Build every exact historical checkout with its own configuration and pinned dependencies: + `//xff/cli:xff_full --config=clang_release --config=xff_full`. +- Disable system/home Bazel rc files; reject dirty trees and workspace `.bazelrc.user` overrides. +- Resolve the configured executable with `cquery` using the same options, then immediately copy + it to its revision directory. Retain source/tree identity, SHA-256, build logs and link actions. +- Require ThinLTO link evidence. Historical compiler/dependency changes are part of this + production-history comparison; results cannot automatically be attributed solely to XFF source. +- Finish every build, including the native resource launcher, before accepting timing samples. +- Keep fixtures on `/dev/shm` tmpfs. The disk holding binaries/logs/results is not the measured + fixture filesystem. No disk-storage throughput conclusion follows from these measurements. +- Rotate historical XFF, fixed PR #1130 XFF, and the traditional tool through each execution + position. Use one correctness-checked warm-up round and nine measured rounds per cell. +- Use the existing chart estimator, mean of the fastest seven of nine. Retain all nine samples + and warm-ups. The existing native launcher measures command CPU, RSS, wall time, output bytes + and first-output time. Python validation/serialization occurs after the timed interval. +- Record affinity, commands, locale, timezone, fixture identity, output hashes/counts, host + pressure/load/memory context, binary hashes and accounting method. Timeouts terminate the + worker process group. Failed attempts remain separate from completed cells. +- Resume only an identical contract. Interrupted cells restart as new attempts. Executable or + fixture identity drift invalidates a campaign instead of silently combining populations. + +The fixed-current participant provides a nearby control for host load. A historical binary that +is byte-identical to current provides an identical-binary noise control. Interleaving reduces +shared host effects; workload-dependent interference can remain. The analysis also computes a +paired-round bootstrap interval using all nine rounds. That interval describes within-cell +variability, not independent-machine reproducibility. + +## Reproduction + +The tools have Bazel owners and support direct Python 3.13 invocation. Building requires an +isolated checkout at `BUILD_ROOT/checkout` and a JSON revision list containing `sha`, `pr`, `date` +and `subject`. Retain this manifest. + +```sh +python3.13 tools/benchmark_extended_build.py \ + --root=BUILD_ROOT --revisions=revisions.json --disk-cache=BAZEL_DISK_CACHE + +python3.13 tools/benchmark_extended_history.py \ + --root=MEASUREMENT_ROOT --build-root=BUILD_ROOT --revisions=revisions.json \ + --fixture=/dev/shm/xff-extended-fixtures --resource-launcher=NATIVE_LAUNCHER + +python3.13 tools/benchmark_extended_report.py \ + --campaign=MEASUREMENT_ROOT --output=REPORT_DIRECTORY \ + --renderer-js=THREE_LANDSCAPE_JS +``` + +The report exports every cell to CSV, endpoint summaries/control noise to JSON, and two datasets +using the existing 3D history viewer: traditional tools and fixed-current XFF comparisons. +The cell CSV includes user/kernel CPU, peak child RSS and first-output latency, taken from the +same samples selected by wall time. `history-by-task.csv` equally weights the shape/worker +combinations using geometric means at each task/size; it omits incomplete groups. These grouped +ratios supplement the individual measured cells rather than replacing them. +`current-versus-reference.csv` uses the fixed-current participant from every historical block +to describe the remaining reference-tool gap for each individual case. Its 10th/90th percentiles +describe the observed spread across those blocks, not confidence across independent machines. +Serve the report directory over HTTP for JSON fetches. `--allow-partial` is for monitoring; the +default refuses incomplete campaigns. + +The historical LLVM 22 linker on drogon requires ICU 70. System installation required interactive +sudo authentication, so the official Ubuntu `libicu70_70.1-2ubuntu1_amd64.deb` was extracted into +the campaign's `compat` directory. `--build-library-path=PATH` supplies those libraries to build +actions and records their hashes. XFF itself does not link ICU. The package SHA-256 is +`223c1e6cebf2a6748637303227d8b84337c14a2d30eacbc46a68d02557dcff3e`. +The package, download URL, hashes and library list are retained in `installed-dependencies.json`. + +## Completed results and workload selection + +All 130 revisions and 7,800 cells completed successfully, followed by a separate 120-cell +endpoint repetition with 27 measured rounds retaining 21. Across the two populations, all +244,080 invocations, including warm-ups, passed their output checks. The +[compact results](benchmarks/extended-history-results-20261107.json) retain every task/size +endpoint comparison, the selected adjacent-source transitions, and the small regex cases. + +The ratios below are geometric means over broad/deep layouts and one/three allowed CPUs. +Old/current greater than one means current is faster; current/tool greater than one means XFF +takes longer than the traditional tool. Endpoint repetition is a separate population, not +additional samples merged into the historical estimates. + +| Task | Files or members | Old/current, history | Old/current, repeat | Current/tool, repeat | +| :------------------------- | ---------------: | -------------------: | ------------------: | -------------------: | +| Exact file listing | 100,000 | 1.09 | 1.09 | 1.159 | +| Native-case name filtering | 100,000 | 2.64 | 2.45 | 1.090 | +| Metadata and UTC date | 100,000 | 1.08 | 1.08 | 1.137 | +| Content regex | 100,000 | 1.09 | 1.11 | 0.721 | +| TAR member filtering | 10,000 | 1.60 | 1.63 | 0.860 | + +Retain these workloads as a separate full-production suite. Native-case name filtering, TAR +member filtering, and small content searches with multiple workers expose substantial changes +that the existing exact-case, non-archive tasks cannot demonstrate. Keep exact listing and +metadata formatting as controls and as remaining performance targets. A positive historical +change is not sufficient reason to hide a slower comparison against a traditional tool. + +The measured transitions agree with specific source changes: + +- PR #1091's uniform filesystem case policy removes unnecessary leaf metadata lookups. At + 100,000 files, the immediately preceding/current-control ratio changes from 2.409 at #1090 + to 1.075 at #1091, while exact listing and metadata controls remain nearly unchanged. +- PR #1105's bounded archive-directory lookup changes the 10,000-member ratio from 1.446 at + #1104 to 1.010 at #1105. Native listing/name/content controls remain close to parity. +- PR #1034 removes Abseil hardware-clock calibration from worker startup. The small broad + regex case with three allowed CPUs changes from about 2.74 times current to about 1.20; + the one-CPU control barely changes. In the separate endpoint repeat, current completes + 100-file searches 2.75 times as fast on the broad layout and 2.52 times as fast on the deep + layout with three allowed CPUs. One-CPU results do not show that improvement. + +The remaining simple-task gap is reproducible. At 100,000 files, current takes about 16% longer +than find for exact listing, 9% longer for native-case filtering, and 14% longer for metadata/date +output. At 10,000 files, exact listing takes about 35% longer. Small 100-file listing/metadata +cases show no historical improvement beyond the observed control variation. Content regex is +about 28% faster than rg in the largest repeated case; TAR listing is about 14% faster than tar +at 10,000 members, although the original current endpoint consumes about 3% more total CPU than +tar there. These are workload-specific results from this Linux guest. + +All three byte-identical current revisions provide 180 control cells. Their 95th percentile +multiplicative distance from parity is 1.0305. This describes the observed noise and does not +make it a universal significance threshold. Native-case speedup changes from 2.64 to 2.45 between +populations, and small deep regex speedup also varies: interleaving does not eliminate every +effect of shared-machine load. Preserve the individual cells and host snapshots. + +## Evidence and status + +On `drogon.boerger.online`, the root is `/home/marcus/Documents/xff-chart-campaign-20261107`: + +- `xff-extended-history-revisions.json`: frozen 130-revision selection. +- `qualified/binaries/SHA/`: production executable and build/link evidence. +- `qualified/build-status.json`: build progress; initial failed dependency attempts are retained + separately under the campaign root's `binaries` directory. +- `preflight-full.json`: 240 full-size output checks across both endpoints and their references. +- `preflight-native-worker.json`: checks through the actual accounting worker; preparation + timings are explicitly excluded because builds were running concurrently. +- `measurements/contract.json`, `fixtures.json`, `progress.json`: frozen population and progress. +- `measurements/cells/SHA/TASK/SHAPE/FILES/CPUS/complete.json`: accepted raw cell data. +- `measurements/cells/.../attempts/`: warm-ups, samples and failure evidence. +- `qualified/logs/build-campaign.log` and `logs/measurements.log`: progress logs. + +The 240 endpoint functional checks and native-worker checks passed. All 130 production builds +completed before timing collection. The +[build summary](benchmarks/extended-history-builds-20261107.json) records 77 distinct executable +hashes; 53 adjacent revision pairs have identical executable bytes. PRs #1128, #1129 and #1130 +also share the current executable hash, providing identical-binary controls in the campaign. + +The independent post-collection audit rehashed all 130 retained binaries and their build/link +evidence successfully. The endpoint repeat used every predeclared case, including slower and +unchanged cases, with fresh tmpfs fixtures and the same frozen production binaries. Its own +contract and directory (`confirmation/`) remain separate from the nine-round history. + +The [completion audit](benchmarks/extended-history-complete-audit-20261107.json) records independent +raw-sample replay of all 93,600 historical plotted values and 31,200 missing positions, plus +1,440 values and 480 missing positions in the repeat. Maximum floating-point difference is +1.12e-16. Chromium checked 96 historical viewer states and 24 repeated-endpoint states across +both dataset views, all task orders and both metrics, without JavaScript or loading errors. +The viewer includes all 130 revisions and direct CSV download links. + +After confirmation, ten diagnostic CPU profiles compared the retained current binary with GNU find +on small and large listings and metadata formatting. Profiled commands write to `/dev/null`; +their results describe CPU attribution and never enter the timing population. In the broad +100,000-file XFF listing, approximate self shares of sampled user cycles are 19.8% in prepared +expression evaluation, 13.6% in the per-entry driver callback, 11.2% in string append, and 8.8% +in `EvalPrint0`; readdir contributes 16.8%. These point to evaluation, entry setup and output +construction as further targets. They are not percentages of total wall time. The short find +profile has only 48 samples and is insufficient for a useful startup breakdown. Perf also +reports an event-description-header warning; raw recordings, commands, sample counts and +reports are retained, and these profiles serve only as diagnostics. + +A separate experiment follows those profiles: construct the per-entry content snapshot's cache +state only on demand, using inline `std::optional` storage. Its source is +`90abd2b3ef63b35833e8f9d96745475c6b9f182a`, based on the unchanged PR #1130 baseline. The +experiment completed all 60 cases for the candidate and an identical-baseline control, with +27 measured rounds retaining 21: 120 cells and 10,080 validated invocations. A separate targeted +repeat adds 16 cells and 1,344 validated invocations. Broad 100,000-file listing is about 1% faster +in both populations; broad metadata/date output is about 0.5% slower in both. Instruction counters +show approximately 66 fewer user-space instructions per file in broad listing, a 2.75% reduction +at 100,000 files. The snapshot grows from 88 to 96 bytes in the macOS construction probe. The +measured implementation and its regression tests are now adopted unchanged on +`benchmark/extended-history-20261107`: the repeatable listing gain is worth retaining, with the +metadata tradeoff documented in the [experiment report](benchmarks/lazy-content-state-20261107.md). +macOS whole-command performance and hash-heavy workloads have not been qualified for this change. +The candidate has no PR number; its standalone measurement manifest uses zero as an explicit +experiment label. It must not enter the merged-PR history or be combined with either earlier +population. Source, tests, build identities and samples live under `lazy-content/` in the same +campaign root. The empty map previously allocated nothing: the hypothesis concerns construction, +destruction and movement of unused cache state, not removing a per-file map allocation. + +The next basic-operation qualification applies four changes to startup, expression results, +explicit output storage and directory path construction. The direct Linux comparison reduces +large-listing userspace instructions by 6-10%, with elapsed gains smaller than those instruction +reductions. Results, remaining find gaps, build identities and next investigation targets are in +[the basic-operation report](benchmarks/find-listing-optimization-20261107.md). Its experiment +catalogs remain separate from merged history. A fifth change defers native filesystem case +resolution until it can change a match. On the Mac RAM fixture, 100,000-file name filtering +takes 71% less time than the four-change binary and 25% less time than GNU find; the complete +Linux controls, smaller cases and remaining listing gaps are retained in the same report. + +The [synthetic viewer check](benchmarks/extended-history-viewer-check-20261107.json) verifies +both exported dataset views in Chromium. Both historical versions produce their exact expected +heights; 60 measured points remain present and all 20 unavailable cells remain empty. This +artifact contains synthetic renderer checks only, not performance measurements. diff --git a/docs/benchmarks/chart-sensitivity-audit-20261107.json b/docs/benchmarks/chart-sensitivity-audit-20261107.json new file mode 100644 index 00000000000..9db705d1fca --- /dev/null +++ b/docs/benchmarks/chart-sensitivity-audit-20261107.json @@ -0,0 +1,310 @@ +{ + "pages_commit": "153d58627f2132b838a091ffcfdb30dd49571b8b", + "source_commit": "ae8c5af3eb11dc8571f11db9b307b0db948f78c6", + "selected_reports": 490, + "checked_points": 3178656, + "errors": [], + "live_catalog_sha256": "bdfe8b375ded842ddea815f8001b816d0ad3faf31a5c3b0855f21193ba5029f8", + "live_catalog_matches_snapshot": true, + "scope": "Recorded sample to chart arithmetic and browser sensitivity; no new performance collection or full executable provenance re-verification.", + "current_performance_assessment": { + "datasets": ["linux / x86_64", "macos / arm64"], + "excluded_at_user_direction": "Local / linux-zen5 / x86_64 / broad/v2 + deep/v2", + "reason": "No recent measurements; retained Linux v2 arithmetic and clipping statistics are historical evidence only and do not explain current CI chart behavior." + }, + "series": [ + { + "dataset": "Local / linux-zen5 / x86_64 / broad/v1 + deep/v1", + "reports": 70, + "distinct_binary_hashes": 38, + "latest": { + "commit": "c33efe99d0df0b4866a9f77fde71dde9959d3cdb", + "date": "2026-10-06T02:40:08Z", + "links": [ + { + "label": "PR #981", + "href": "https://github.com/mboworks/xff/pull/981" + } + ], + "report": "local/linux-zen5/04f25c4ca10d9ab4894b96320aa99eb84ec0ecf45368df692ed4002baf980cb2/c33efe99d0df0b4866a9f77fde71dde9959d3cdb/", + "default_points": 468, + "default_capped": 0, + "half_time_still_capped": 0, + "omitted_xff_tasks": { + "files-safe": 78 + } + }, + "mainline_commits_after_latest": 128 + }, + { + "dataset": "Local / linux-zen5 / x86_64 / broad/v2 + deep/v2", + "reports": 72, + "distinct_binary_hashes": 38, + "latest": { + "commit": "9210100af8007a2f17b22597a349714d9e6069e1", + "date": "2026-10-06T22:08:43Z", + "links": [ + { + "label": "PR #985", + "href": "https://github.com/mboworks/xff/pull/985" + } + ], + "report": "local/linux-zen5/b7bb50f259fd384e20e29cc69874178dc2ac9221137017998cbcc709ed87f6f9/9210100af8007a2f17b22597a349714d9e6069e1/", + "default_points": 468, + "default_capped": 42, + "half_time_still_capped": 8, + "omitted_xff_tasks": { + "files-safe": 78 + } + }, + "mainline_commits_after_latest": 126 + }, + { + "dataset": "Local / macos-m5-pro / arm64 / broad/v1 + deep/v1", + "reports": 72, + "distinct_binary_hashes": 41, + "latest": { + "commit": "9210100af8007a2f17b22597a349714d9e6069e1", + "date": "2026-10-06T22:08:43Z", + "links": [ + { + "label": "PR #985", + "href": "https://github.com/mboworks/xff/pull/985" + } + ], + "report": "local/macos-m5-pro/14620686da0d294b9bf80298fa064467e2fa3e45923e4b827ec34e77b34b9dde/9210100af8007a2f17b22597a349714d9e6069e1/", + "default_points": 468, + "default_capped": 0, + "half_time_still_capped": 0, + "omitted_xff_tasks": { + "files-safe": 78 + } + }, + "mainline_commits_after_latest": 126 + }, + { + "dataset": "linux / x86_64", + "reports": 138, + "distinct_binary_hashes": 80, + "latest": { + "commit": "0e95e191ba7d7ee3769217e7fbf82a825ff9b90d", + "date": "2026-11-06T19:06:09Z", + "links": [ + { + "label": "PR #1122", + "href": "https://github.com/mboworks/xff/pull/1122" + } + ], + "report": "runs/42276661623/1/linux/", + "default_points": 468, + "default_capped": 0, + "half_time_still_capped": 0, + "omitted_xff_tasks": { + "files-safe": 52 + } + }, + "mainline_commits_after_latest": 9 + }, + { + "dataset": "macos / arm64", + "reports": 138, + "distinct_binary_hashes": 138, + "latest": { + "commit": "0e95e191ba7d7ee3769217e7fbf82a825ff9b90d", + "date": "2026-11-06T19:06:09Z", + "links": [ + { + "label": "PR #1122", + "href": "https://github.com/mboworks/xff/pull/1122" + } + ], + "report": "runs/42276661623/1/macos/", + "default_points": 468, + "default_capped": 0, + "half_time_still_capped": 0, + "omitted_xff_tasks": { + "files-safe": 52 + } + }, + "mainline_commits_after_latest": 9 + } + ], + "browser": { + "synthetic_control": "halve every XFF elapsed sample; reference samples unchanged", + "errors": [], + "latest": { + "commit": "0e95e191ba7d7ee3769217e7fbf82a825ff9b90d", + "version": "138 of 138", + "metric": "percent", + "range": "100", + "picks": 74, + "maxError": 0, + "heightRange": [-49.41909765688375, 83.75368932652991] + }, + "previous": { + "commit": "2487927cc6b1de326ea3c6c058dc493214354bec", + "version": "137 of 138", + "metric": "percent", + "range": "100", + "picks": 75, + "maxError": 0 + }, + "counterfactual": { + "checkedPoints": 468, + "maxError": 1.4210854715202004e-14, + "picks": 66, + "originalScreenshot": "554cb3e9ff0d7efb57cd143a6eafeac64a51ba2b0a633616f79c65d7cf0069ad", + "syntheticScreenshot": "f983742aa29228392c8cb9792b0ca1deef7134c8ca8517e1413504f876da93c0" + } + }, + "linux_1093_1094": [ + { + "platform": "linux / x86_64", + "date": "2026-11-04T23:39:42Z", + "commit": "a7a6125a9358f1020fc914d6c91bbf8c6e66392f", + "report": "runs/41935477473/1/linux/", + "binary": "c4a734d126d335b293510ecb77d0f7f59aea19b942bb200a7ce5434ba56b8a33", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "63.65512385713958", + "reference_ms": "47.569683285709225", + "ratio": "1.3381447901349115", + "height": "-33.81447901349115", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + }, + { + "platform": "linux / x86_64", + "date": "2026-11-05T01:46:19Z", + "commit": "bb0185a0379075480eb8b1499f5bc5ff8cfafaa8", + "report": "runs/41950760925/1/linux/", + "binary": "b1a7bea12f32f8ded3413f4b6b99a7720f17e24227c9135b284d98f50bcf1edb", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "59.88791642857905", + "reference_ms": "48.28247728571", + "ratio": "1.2403654450908606", + "height": "-24.036544509086056", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + } + ], + "linux_identical_binary_control": [ + { + "platform": "linux / x86_64", + "date": "2026-11-05T17:08:19Z", + "commit": "55ea67e3f06e5055b43d8cb780661901731592f2", + "report": "runs/42071636652/1/linux/", + "binary": "09c997ab01d2d7dfe916bf1cced7b54757c6b6b25f8d2a9743812e9db23efb51", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "57.341299714279", + "reference_ms": "47.05371942858148", + "ratio": "1.2186347946693585", + "height": "-21.863479466935853", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + }, + { + "platform": "linux / x86_64", + "date": "2026-11-05T18:53:16Z", + "commit": "f3ec0faf7a1bb16ddb0b3b8bcee2c3e5bd970df2", + "report": "runs/42088571729/1/linux/", + "binary": "09c997ab01d2d7dfe916bf1cced7b54757c6b6b25f8d2a9743812e9db23efb51", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "64.83135542858268", + "reference_ms": "51.71553057143846", + "ratio": "1.2536148176808584", + "height": "-25.361481768085838", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + }, + { + "platform": "linux / x86_64", + "date": "2026-11-05T20:46:57Z", + "commit": "455dcd8eb5dd98b09f3117f5316136b6d43cfd8e", + "report": "runs/42106576310/1/linux/", + "binary": "09c997ab01d2d7dfe916bf1cced7b54757c6b6b25f8d2a9743812e9db23efb51", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "62.68778028572797", + "reference_ms": "48.794140857138146", + "ratio": "1.284739913123346", + "height": "-28.47399131233459", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + }, + { + "platform": "linux / x86_64", + "date": "2026-11-05T22:29:23Z", + "commit": "245e74ff6cbe6c0f84a074be669c60ac7cbc5e8f", + "report": "runs/42121915666/1/linux/", + "binary": "09c997ab01d2d7dfe916bf1cced7b54757c6b6b25f8d2a9743812e9db23efb51", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "60.077836714283094", + "reference_ms": "48.359569285712006", + "ratio": "1.2423153804232347", + "height": "-24.231538042323475", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + }, + { + "platform": "linux / x86_64", + "date": "2026-11-06T00:26:31Z", + "commit": "b60cf7a5a92609f9fadddd4759d3c55e755a69b6", + "report": "runs/42136840761/1/linux/", + "binary": "09c997ab01d2d7dfe916bf1cced7b54757c6b6b25f8d2a9743812e9db23efb51", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "61.81004171427925", + "reference_ms": "50.18462614285519", + "ratio": "1.2316529276980412", + "height": "-23.165292769804125", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + }, + { + "platform": "linux / x86_64", + "date": "2026-11-06T03:31:50Z", + "commit": "ccb1f0a202ed59b30246c14e424a400e47acc447", + "report": "runs/42157108661/1/linux/", + "binary": "09c997ab01d2d7dfe916bf1cced7b54757c6b6b25f8d2a9743812e9db23efb51", + "dataset": "broad", + "task": "files", + "cpus": "1", + "files": "100000", + "reference": "rg", + "xff_ms": "63.105239285716515", + "reference_ms": "48.80616985714629", + "ratio": "1.2929766763182406", + "height": "-29.297667631824066", + "fixture": "4fec4112050c07e58e1c6d30ba3049d0868d9cf576a1ebab6c5bff793999b025" + } + ], + "evidence_directory": "/private/tmp/xff-chart-evidence-20261107", + "artifact_hashes": { + "audit.py": "5109db79d01589b40c626e86618dac8602dcf0f3c596ebbf88eb66d7a5e10941", + "audit-summary.json": "af8f443033f40a38320b1f5192561423d73638750e886e7d4629b43ad386997f", + "cells.csv": "8a7dc35d997cfbd52507b2d6b3db3bd1885a3bba4915962cf7bf477c18661a02", + "browser-check.mjs": "35be5509a59bff8ea86b10b853d9fdfded7a6bf6d7ea61147317510004d21d7d", + "browser-check.json": "73b1fc94408f21998f7f4c42e3c26f97f7deda04387be00274e0144b0b0a1c58", + "browser-original.png": "554cb3e9ff0d7efb57cd143a6eafeac64a51ba2b0a633616f79c65d7cf0069ad", + "browser-synthetic-half-time.png": "f983742aa29228392c8cb9792b0ca1deef7134c8ca8517e1413504f876da93c0" + } +} diff --git a/docs/benchmarks/extended-history-builds-20261107.json b/docs/benchmarks/extended-history-builds-20261107.json new file mode 100644 index 00000000000..6b118c3c3a9 --- /dev/null +++ b/docs/benchmarks/extended-history-builds-20261107.json @@ -0,0 +1,1231 @@ +{ + "target": "//xff/cli:xff_full", + "configs": ["clang_release", "xff_full"], + "manifest_sha256": "759b4894bf37262898630815cdf827a0a290ecbe106d75d85e5d573564f8fe57", + "revision_count": 130, + "distinct_binary_hashes": 77, + "identical_adjacent_binaries": 53, + "revisions": [ + { + "pr": 977, + "sha": "21c7f3656b005b23113d936c1cd2ca0fd2221ab2", + "tree": "396bbbb94ae043cb84672d7abbcd5cdb7e7b9e09", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "400ada11d7122587013d2fcbefc9bd6fd7e6aa80878867ed7046f915f2d8087a", + "elapsed_seconds": 75.14972471701913 + }, + { + "pr": 981, + "sha": "c33efe99d0df0b4866a9f77fde71dde9959d3cdb", + "tree": "8b009345d5e4ac726f07835f6a8f5dc58761b2ba", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "856a3d3720b2275136c5e2278731e4570a1852edeffe98e68abf7c79f725cb3b", + "elapsed_seconds": 0.89143300591968 + }, + { + "pr": 982, + "sha": "103fbf65b22979f75f5adbac67a53f15cf74d03e", + "tree": "8469b6f66af9d3821ad59186cd6a99b3551d0e81", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "d3acf93daf4654871a2bac3dc179ad167caa365738a5dd47762ebc2b8eb7fe80", + "elapsed_seconds": 0.6069001959403977 + }, + { + "pr": 985, + "sha": "9210100af8007a2f17b22597a349714d9e6069e1", + "tree": "d76ccfa5a38cc30af8b71f2ada872fd0a8037ff7", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "e94d6646c7ea5de7fc2013ebd206d1bfc7ad52184dfc57ef18fc465697cd2d88", + "elapsed_seconds": 0.6095801409101114 + }, + { + "pr": 986, + "sha": "61ab1ce41300aa785d6beafb46c29b29dc832b8d", + "tree": "a0dce9fc2f1eeb67a3fd6e99d10534b8a5adc527", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "2dd7cd4ddd5bf7f15ed432bd393a46573bc39d99f18aa44dbea4f598bf531ede", + "elapsed_seconds": 0.5166276399977505 + }, + { + "pr": 987, + "sha": "4bce0bb39186d1dfbe122038f17ef660447599c6", + "tree": "73044eba04517e538b8f7bf8143eccb8a08bc702", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "4e2a1439ee3422d6311ad3b5fdcdb6fc607416a2dcebeddde0aebe582fb1ee52", + "elapsed_seconds": 0.5408426729263738 + }, + { + "pr": 988, + "sha": "fa41587198981a5619e408c41be80cb22b8dd439", + "tree": "bf7951eaac026e4fea79100253623ba5f02bd93f", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "e2af2a7f5f5176289967a5c4d3fb7363730adb43cb85da0d8970fbd6fa398189", + "elapsed_seconds": 0.5303708449937403 + }, + { + "pr": 989, + "sha": "772994ab7905be77915978f06ea90ae5934aaeef", + "tree": "8f797cae4320ba5cb497d580eb4b158f5eaf007b", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "b75271b5a7a3c29289770b7ab50519de29b046e3dcd4369a367a380433b6e216", + "elapsed_seconds": 0.5656200320227072 + }, + { + "pr": 990, + "sha": "4ea895f63106f05df7c90b629d20433ae1e03016", + "tree": "a56a093c3fdcb1af6c93fa4cb805cdad724b1707", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "4f3136d1fa6ac0d3f44cdd5a0017e6d01373fd25e372e8c9e9c6b1f898b0ad96", + "elapsed_seconds": 0.5688729950925335 + }, + { + "pr": 993, + "sha": "dac3747d63cad713def0b949a934dfe36f82da63", + "tree": "08ce5a524ac2af07dac04846fec69757cde99be4", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "aa78e865c8e8998d19597a7e13bccb7ee8579db9dbeeeaee2d9fd324a3a23d2a", + "elapsed_seconds": 0.547393971006386 + }, + { + "pr": 994, + "sha": "88d4facd15ebd00acf749222b3028de2e8916970", + "tree": "db9ef3cd231ef81fd50e1db276469648e70e7266", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "04f63a1e2776d59bf2a8ac152c7e8ab006b8d9643957fd2e4dd8430f78a21dc3", + "elapsed_seconds": 0.7202342130476609 + }, + { + "pr": 999, + "sha": "bbc0bf9376c7fc41fe75094998c3c7e74bd02e94", + "tree": "38d5ecc9e1789f0f0a187960c24daee1f7884da0", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "664892ae86605427fa7762ed9b387aaaecaf4097d86f38e6d393130438c28f0a", + "elapsed_seconds": 0.5682561640860513 + }, + { + "pr": 1003, + "sha": "b137c8a6800aa0c1d6f2d67342f291b25783747f", + "tree": "9d797c1330a4369394feb3fcbdb700b3c26557c4", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "abf111a85f39ab32c26aeb77f62382bd53a3e64c25f4d0c20849bb3e059417e2", + "elapsed_seconds": 0.5620602199342102 + }, + { + "pr": 1004, + "sha": "d73eea93ac97f401fe12ba2ba139eb6b8601ec19", + "tree": "2eadb23385811cad1adb6e428d9ecb58b0828247", + "binary_sha256": "f8577e4753dc90640bd926ac80ce7277be9791491bf4e15bfdcd1a3777ef8e47", + "bytes": 17651872, + "build_manifest_sha256": "f5adc29df05ba25b80e6079797e0175ad189f91677d8a113dc4eb8f0f1c67afe", + "elapsed_seconds": 5.435096765984781 + }, + { + "pr": 1006, + "sha": "20095dd53c31e510aac2256fc93d34026e4f463c", + "tree": "6d5d24ce2849ba5a16d028b0b83edc06bb2e41da", + "binary_sha256": "89c945084c20987f773222b9dd6411c5705ed5009f67f9514248b72bb9d48484", + "bytes": 17652128, + "build_manifest_sha256": "e31cb8c749292da02d2c6d150e9c89e216cf8b7f6ad134beb302cf0677bdcb7e", + "elapsed_seconds": 28.295815887046047 + }, + { + "pr": 1007, + "sha": "33a01e13d7cd27ee7f866802fc2f74998fdcaabb", + "tree": "1226bc110bb9a1004be74107e23fd194e9f30a0f", + "binary_sha256": "89c945084c20987f773222b9dd6411c5705ed5009f67f9514248b72bb9d48484", + "bytes": 17652128, + "build_manifest_sha256": "4b07329c072c1e0635d4e8ee87f62b8426b676eab581d8e292875269470a8a5c", + "elapsed_seconds": 4.9203253800515085 + }, + { + "pr": 1005, + "sha": "bfe77198c06bc1e4a23e23ea292ab47cb4b6a0e4", + "tree": "c8fb309f5863ef1ec06c94dd94d0b0af845932f4", + "binary_sha256": "89c945084c20987f773222b9dd6411c5705ed5009f67f9514248b72bb9d48484", + "bytes": 17652128, + "build_manifest_sha256": "c87d03c0711fcfe2d7dbc47dc7a924198e925d5fa2fdbc8b2035c6d55e6d540c", + "elapsed_seconds": 12.504761731019244 + }, + { + "pr": 1009, + "sha": "1f85d90e3441737304d9f3647523cfc408ca54a9", + "tree": "8eff6419aaace3b3d55ac13cf57e281e1f5f15f6", + "binary_sha256": "89c945084c20987f773222b9dd6411c5705ed5009f67f9514248b72bb9d48484", + "bytes": 17652128, + "build_manifest_sha256": "e87b6b7f07447603b44993f2277d8696e347958f085ca1e20837c6e32acba4ed", + "elapsed_seconds": 1.9633059169864282 + }, + { + "pr": 1010, + "sha": "a5f9c9ec07419101cfe73ec4b42c3c29c529edad", + "tree": "898b64ea26fd89182653fd004a846882ab26d47c", + "binary_sha256": "89c945084c20987f773222b9dd6411c5705ed5009f67f9514248b72bb9d48484", + "bytes": 17652128, + "build_manifest_sha256": "6ed629c53c8b923ca8e902681c0fbaaef4e3ecb7a3e2da7d4afe2d2737baf3a3", + "elapsed_seconds": 1.5160633369814605 + }, + { + "pr": 1008, + "sha": "a21ada79bbe9cad232a174cfdb4e8923ed891f2a", + "tree": "f6fa05e9d31fece19f10872b030bbc308d6ef7d1", + "binary_sha256": "89c945084c20987f773222b9dd6411c5705ed5009f67f9514248b72bb9d48484", + "bytes": 17652128, + "build_manifest_sha256": "2818f8b75beb79bc504e38c6f4aad8844228d1eba3033dada0c3dce95c299e90", + "elapsed_seconds": 159.1304149379721 + }, + { + "pr": 1012, + "sha": "ae62c828a3f3502a9bcf4805188913a1aaaf264c", + "tree": "1712ccb4b9857795a27ef4169a0695e2f6eddce9", + "binary_sha256": "89c945084c20987f773222b9dd6411c5705ed5009f67f9514248b72bb9d48484", + "bytes": 17652128, + "build_manifest_sha256": "e52174c74b60c06b958067cc78244bff348bf9b871c44436a89ecd246a5be000", + "elapsed_seconds": 0.7854754580184817 + }, + { + "pr": 1011, + "sha": "801087f3e9a8bf192928896c7f24c369003d1e7b", + "tree": "54e959ef24d61db598379da3e5ebf160bbef262e", + "binary_sha256": "ec53e6ebbb6d1dd4aa1a99d59404ae183d0edcac20df8f69f8228655db3e59ac", + "bytes": 17767888, + "build_manifest_sha256": "0f5039e09e342e5bc743196e38f58a751c665cec80b9144a811669cff40e5f39", + "elapsed_seconds": 76.2379414329771 + }, + { + "pr": 1013, + "sha": "3dbc47cc2a1d84c0e6b60f0a497c1d3ce160351f", + "tree": "994c60029718dc7123d60f41d88ba0048eefa4e2", + "binary_sha256": "ec53e6ebbb6d1dd4aa1a99d59404ae183d0edcac20df8f69f8228655db3e59ac", + "bytes": 17767888, + "build_manifest_sha256": "efbc7073dd4f30214e9ec249b56e44d424b663a39bfab7b38db0c223fcf6711d", + "elapsed_seconds": 1.1680861730128527 + }, + { + "pr": 1019, + "sha": "8e95f5546187b2a6f4ec165af9cf794af18ac4a1", + "tree": "b4ff119af9eb51555216200e080c843854ef6c92", + "binary_sha256": "7d2cbe55218fda321b6894717c6a5deeb1e679641b3c10db52af6a8a40f7e0d5", + "bytes": 17882880, + "build_manifest_sha256": "fbb3b922cc58cb0dea35c9d733b997ab828e3e64a4d42982454d1da7a5a5db56", + "elapsed_seconds": 18.508985477034003 + }, + { + "pr": 1021, + "sha": "1642f49d7b400596af3ed627f5b9f42cc24e4237", + "tree": "b5399eee33c2f3d23b862b3b48cc98fc7eddc4e5", + "binary_sha256": "7d2cbe55218fda321b6894717c6a5deeb1e679641b3c10db52af6a8a40f7e0d5", + "bytes": 17882880, + "build_manifest_sha256": "878980f78820a3ce9466dbc46888eef053203a31a5bd9472680556a6a6665fcd", + "elapsed_seconds": 0.5626644470030442 + }, + { + "pr": 1020, + "sha": "eaa034527a286ed87f1f74b8e88ba5b7007fb31a", + "tree": "babc8e9bc78da96ddd01ca71dd25185d02386127", + "binary_sha256": "7d2cbe55218fda321b6894717c6a5deeb1e679641b3c10db52af6a8a40f7e0d5", + "bytes": 17882880, + "build_manifest_sha256": "8acd12910fcfff1b9832b17664786104696e7beba45f9b86be8dce148548c024", + "elapsed_seconds": 0.5181690179742873 + }, + { + "pr": 1022, + "sha": "02292572cac61101036c032ece8e11675d580d7e", + "tree": "a85d7dc78c242955dca7dbc66a50200c7a2dbb13", + "binary_sha256": "0c78e33b6a3ea712686eea249d26ad02b422470531d1092b64b6721e2362fa8e", + "bytes": 17958792, + "build_manifest_sha256": "8f82230f43b43ff3c49a14a0349d1583606ac4ac035020db694c19c9bbdab6e4", + "elapsed_seconds": 11.223397571942769 + }, + { + "pr": 1023, + "sha": "b52571f81b8ecec116a4249f51b7d5e72175248c", + "tree": "ae7c43483a26f479eea45438aeda15e30ddd0572", + "binary_sha256": "18242300e2c72ebc3fc3221180245ff2ac4240cb4945610840165d63a13f48ed", + "bytes": 17942672, + "build_manifest_sha256": "969d7b9bb508b5cfb115647813c6ae6e305a54d2ed022c7d32ea511eb0c4ecc8", + "elapsed_seconds": 20.09151629707776 + }, + { + "pr": 1024, + "sha": "f0407980edd2bc2497dc0f406b2fed1977caaaea", + "tree": "7e8fdbddb1ea682d4db19a9a767077560135e52b", + "binary_sha256": "673fb8d4c626a9bcbb141b0629a92fdbec0a4b6bc3c968bd9328b6eb9a5143f6", + "bytes": 17968672, + "build_manifest_sha256": "c6278a5611fc124366ea3d85d5d028deb73796be176fec8f6970f23a6b53c56a", + "elapsed_seconds": 12.889048965997063 + }, + { + "pr": 1025, + "sha": "4c87962565391caf32b669c6a8a55d7495999921", + "tree": "a31583f93a3befa38dcc21facdf8b9a1be28d549", + "binary_sha256": "55e0cf69118d43d6ccfff0ae848edb0f1b4831acb0a7fc029ffc11fda7316d44", + "bytes": 17986200, + "build_manifest_sha256": "842dcd01d74b5755dff4e2bd8547a418f13af412cdf425d94747c530f5d5e789", + "elapsed_seconds": 12.295493853045627 + }, + { + "pr": 1026, + "sha": "b7fd2c2d0c5d50d8e5895f36fe39f802ac2dcb76", + "tree": "30471bc50f1e3a8ef4ae0919f1320e8161419b74", + "binary_sha256": "55e0cf69118d43d6ccfff0ae848edb0f1b4831acb0a7fc029ffc11fda7316d44", + "bytes": 17986200, + "build_manifest_sha256": "cd3830008cf166dc0f4f3ce007bea7d5cd5d2dde2773aecfa79f8f9840bf7e5b", + "elapsed_seconds": 0.5216331530828029 + }, + { + "pr": 1027, + "sha": "d406f4132d067d4e87a8df1426753a7d0203abd6", + "tree": "4bf27451fc57d54a3048bc8883d9036ca3c28382", + "binary_sha256": "87da17972facc51a726540367e0ab90d8eeb94a37bb0bb0e6454430f7d707198", + "bytes": 17985512, + "build_manifest_sha256": "64b14a53fe2d20d80f9d357708716cfe4a1ad97e5dc83e8ebaaf9ac255093fdb", + "elapsed_seconds": 10.479590691975318 + }, + { + "pr": 1028, + "sha": "d47b00bfeeb3b98606d806c4b21664870d3ddfaa", + "tree": "f60dfaeb147725edd27f4d1e22215fa42fb77e5d", + "binary_sha256": "c594249b32181aa2708081a51e3fd1d80876f87a1a1c14de5dc745192f74916c", + "bytes": 17993920, + "build_manifest_sha256": "6cc1c5ff26c7af96714448ad3fb8ed06d363b8c88cbe6a812332a908a43a2e11", + "elapsed_seconds": 6.61649262602441 + }, + { + "pr": 1029, + "sha": "3292b6f308ab92f61d8575c95ee2cef2c41e4205", + "tree": "02d6a9bef548a0d29d1fa27507ba55ddfa7f43ab", + "binary_sha256": "c594249b32181aa2708081a51e3fd1d80876f87a1a1c14de5dc745192f74916c", + "bytes": 17993920, + "build_manifest_sha256": "b7ae5e6aae8f4da83d914dd1cdfdae0cf34ac76bdfe546400470ebaf18319fe2", + "elapsed_seconds": 0.5411934440489858 + }, + { + "pr": 1030, + "sha": "96174bbdd64ab2325224f47bab43888fa224595b", + "tree": "7e14c5b2dc2a87bbdef99cf0f332a2a1683f1a9c", + "binary_sha256": "c594249b32181aa2708081a51e3fd1d80876f87a1a1c14de5dc745192f74916c", + "bytes": 17993920, + "build_manifest_sha256": "5db2eb61126c0b47756a0b3cc1021a29a865604dfed131511acc9010574f4943", + "elapsed_seconds": 0.5303470180369914 + }, + { + "pr": 1031, + "sha": "bfae14510a3e302f524b96719a695ca4bb07ffbd", + "tree": "af54e0265fcf695c3228b9fd03ad8d6a4c2f2205", + "binary_sha256": "c594249b32181aa2708081a51e3fd1d80876f87a1a1c14de5dc745192f74916c", + "bytes": 17993920, + "build_manifest_sha256": "3df309378fbb3b753cbda054c405a3b73f62f580b2965e42899beccd253c50af", + "elapsed_seconds": 0.56243567308411 + }, + { + "pr": 1032, + "sha": "3803544ef4a24e0a72e54a317ee5091638bc70ae", + "tree": "c678a8f9d5f9c2bd63f3bf2cb0063f9b5b9667f2", + "binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "bytes": 17999936, + "build_manifest_sha256": "e5b5b901d344cb2e08e46409c54925fe3f25633517ba2937a78236b6de6ca4ec", + "elapsed_seconds": 5.533379688975401 + }, + { + "pr": 1033, + "sha": "a721b98a306dd9021d31bbc485ae4c7c82ceba00", + "tree": "37a1058547dd87ee790790c77add1956b658c8e5", + "binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "bytes": 17999936, + "build_manifest_sha256": "3eddb404dc68ba2716a028b70eb638bcc9a1a2b114e914f04a900f93a6d2a5c2", + "elapsed_seconds": 3.488350010011345 + }, + { + "pr": 1034, + "sha": "974d137026818bba1c1deaf6cfc4fffe676b314e", + "tree": "cf0755b74daea7bfdec70a96f260f327c37af885", + "binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "bytes": 17994032, + "build_manifest_sha256": "7c9a7aee3251bfc415fa218f3029010eaf6679c264f32d28db20a48aefa2a6ba", + "elapsed_seconds": 68.6122232839698 + }, + { + "pr": 1036, + "sha": "66302319f016c5f459b0260a2e727bd32073ed24", + "tree": "dc810d26cb1e36e113e9b56854f4ca95cf45c3ce", + "binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "bytes": 17994032, + "build_manifest_sha256": "d1c6ba65c305f27a209837f8a838025bac7bbdaeb5b75c8e30d104b43003a2a6", + "elapsed_seconds": 0.5424148209858686 + }, + { + "pr": 1038, + "sha": "b68a9c3a58abd219a5043d5737e23f6ebe5ee26c", + "tree": "f681932162fcf64f4991341fd4bf7cf634dea218", + "binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "bytes": 17994032, + "build_manifest_sha256": "336a0f8277cb195fe8641b3b5e32676fb394f5a7b695232463fd2a8272c6c9d5", + "elapsed_seconds": 0.5670382109237835 + }, + { + "pr": 1035, + "sha": "8ff28cde9c67bd498f9016935da01506ffb5845c", + "tree": "715ee9cb9b51df3fcbbe11a375ac1c7781dd49fa", + "binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "bytes": 17994032, + "build_manifest_sha256": "98d4e512101cdf026af07ee6a6dd5dd3d03d4f3c1c8d060d1adf1f92b02fa670", + "elapsed_seconds": 0.7041487760143355 + }, + { + "pr": 1037, + "sha": "473f73452a6b47d7a3b522f2cc6128c4fafa86d8", + "tree": "6ec296c7c8786aa4006cefd6a965291e5db97b44", + "binary_sha256": "aea1c4b7d8f5480dfbd37ba01e9fab6071f73d4b768999a7d7e97a57152d0a0e", + "bytes": 17994456, + "build_manifest_sha256": "064a87023483103bc02e6c4e914ad22a39f2aac95e0f43476b19eee676e49fbe", + "elapsed_seconds": 11.155752036953345 + }, + { + "pr": 1039, + "sha": "7b72a5f0a52e838dfe0b199ea0386c8e6b3dcd39", + "tree": "68f10c304d6aedc71df92ccc469c1e202e9bb30b", + "binary_sha256": "5ad2508ca40ef3f190661110e4550a120e1b6e32520d57186050e092d4bc1119", + "bytes": 18007664, + "build_manifest_sha256": "a24bf2af15eb7f2f4fcf938b2e8dd62c1036434d34f3208a9ebfb7afcc40b803", + "elapsed_seconds": 5.7498900019563735 + }, + { + "pr": 1040, + "sha": "16e70cb97de93c7ab4ae8c9e990e1842d50cc528", + "tree": "42fb88ef117e2eaae6a8ea895b172fa39b51ecae", + "binary_sha256": "880d77f87179c4b26631c6a75f9678a2063e2b02aed79a9c5f66e3d54cd55118", + "bytes": 18007680, + "build_manifest_sha256": "cfda4127ee02255e6b6b80d4e62f4e5f85a4808330e32a1f2e899af395ca6a75", + "elapsed_seconds": 15.649529470014386 + }, + { + "pr": 1041, + "sha": "cf23601ab3533c2acb938acda1439dcd69091f61", + "tree": "28f1735cecbd92563d97215c03e568447edd7f47", + "binary_sha256": "817df8c863e331f6e6e94bf8545f0548d5a00d6a8dca3a3e98e2b97145a3a35c", + "bytes": 18008064, + "build_manifest_sha256": "81e7e5c31062c5160806d092d8e2faebbcc8b78adf695486199f237f7584f5dc", + "elapsed_seconds": 17.126204880070873 + }, + { + "pr": 1042, + "sha": "2b21790502fd6bf9b6e1afb53cc1444cf140f296", + "tree": "203c55ed0fa72c1b90a023e45c1f7f73714b2194", + "binary_sha256": "cddce69097f55e6f18f4086a9d0905f6e72b73c774e51e89d9bbaafa3eb9057b", + "bytes": 18021664, + "build_manifest_sha256": "4cc1eaab866c3001b92c260e9c8dd40c5add2914cbc5d10675983eac92e9121b", + "elapsed_seconds": 10.269586473936215 + }, + { + "pr": 1043, + "sha": "9e4338a6ea3b47431e612a1fa24b818b3269193d", + "tree": "3fdc698f88d9cd86a18f571240ba1d95deb48798", + "binary_sha256": "573dfb96a507651088d7e127b43fe836a6aa8d4ffe222bb4761ffaee52b48443", + "bytes": 18030080, + "build_manifest_sha256": "c39e412b8a5893a726958e064edf388fecbb7e5be788f9728c1eef864880a6d4", + "elapsed_seconds": 20.327275358955376 + }, + { + "pr": 1044, + "sha": "d546fcb3d864ed18776f642c1aa0fe904e9f8bfa", + "tree": "b1d2b95065e3480026687d3e625d36937382722f", + "binary_sha256": "9ba587a75ce9ed5df3b9f50d896812e552304649e11318fca02c0585840bb091", + "bytes": 18010352, + "build_manifest_sha256": "a74076df2b948baf56ebe15a1d41427c2c1391990c035bf02ad5debc342fa39c", + "elapsed_seconds": 8.525545189040713 + }, + { + "pr": 1045, + "sha": "35479b4fe8dec5a7a9400bca69f69516df5f56f0", + "tree": "012189800cc12490352e17898cb4a00e1ef52a2b", + "binary_sha256": "9ba587a75ce9ed5df3b9f50d896812e552304649e11318fca02c0585840bb091", + "bytes": 18010352, + "build_manifest_sha256": "3e8ae6d81382f98f379f974b1eee72934fe2552204fd8975b00193216b33172d", + "elapsed_seconds": 1.4121523729991168 + }, + { + "pr": 1046, + "sha": "7c0f507f7c815146a9b746e40269377dbc768b37", + "tree": "a4849e989e52f62de9fdababdebfd234890560bf", + "binary_sha256": "8a54a896cabb96d22d1f71337b6306ae91e751d626edf9737dd40ec236b0d2d5", + "bytes": 18010216, + "build_manifest_sha256": "755eeed74b0629fe6760f784edc5684cdb4af5fefc7c7a68254c0f65cf483fdd", + "elapsed_seconds": 7.990364472963847 + }, + { + "pr": 1047, + "sha": "c14d39cf281c084f8833bc877fca6999e2f9f810", + "tree": "886fbeee2a5dda370bdc9f3fe0ea258734af0e7d", + "binary_sha256": "088e5123ec23e4cf1534285f250e640eb34af3da1f62d86d434e1d949e1b2662", + "bytes": 18023808, + "build_manifest_sha256": "52afc491c64f78d4cc64e80f11e9d3abe4d553475230fbc4cdc1f169e03338be", + "elapsed_seconds": 38.43270433798898 + }, + { + "pr": 1048, + "sha": "7cf2a52441d626888b5840d09a4646d6dedca6b9", + "tree": "b381293e0070ed080653db6cc0845a5b990902c7", + "binary_sha256": "d324b15425ba0de73e08e1573ab43cf1005e22c51f7582df848e9235241cf292", + "bytes": 18009688, + "build_manifest_sha256": "b79238f4de2c21f43f394fad45c1c63485c1d3ab8c72e12c371c1d26327d9123", + "elapsed_seconds": 9.378784344065934 + }, + { + "pr": 1049, + "sha": "901c8fea916124f4d0e195c5385f2a977b44093d", + "tree": "67650cbee83feb346f32287a257c57eac4f63a01", + "binary_sha256": "dc0a69c21f79b5b5fa2f4bf2bd271bcc96f8559398a00bc2802f4c12661247d5", + "bytes": 18009056, + "build_manifest_sha256": "e43a147649b273fd1f0d6e780fbb5877ee1b54c677cd5ce26e2f86b0ad2a850b", + "elapsed_seconds": 13.595240822061896 + }, + { + "pr": 1050, + "sha": "2d615ea1e447e55c266a47799ad6cd64bd4e246d", + "tree": "86e30a4579b6af6c4c7669f7c8123af02d860399", + "binary_sha256": "93a5b3e92f7da7abd981867f2c42a6946b821be1138048466429775be2eb9c50", + "bytes": 18006744, + "build_manifest_sha256": "0c95422cf7c1d3356fe327c09034f56b38488f4905ea1fefe4bf22ca9eeb6900", + "elapsed_seconds": 15.034358096076176 + }, + { + "pr": 1051, + "sha": "d903ea98a98f4220d9372ab0404ee974eccb8690", + "tree": "321291bd065687458abeef7489dc164c0c47ef64", + "binary_sha256": "c79849b306fd1a6f83082e0436a5e66935221de9b0c5551a1bdd7a879f142d82", + "bytes": 18007024, + "build_manifest_sha256": "60ae9d102db973c82383e32b668a69747c17dcc5841de8a6cca416d1857f11ed", + "elapsed_seconds": 15.807729575084522 + }, + { + "pr": 1052, + "sha": "76cc22da343841f9786bc9f78e21e839084a780f", + "tree": "a8aea9ac22a2eec2eb46be737b24d6902d7cf805", + "binary_sha256": "c79849b306fd1a6f83082e0436a5e66935221de9b0c5551a1bdd7a879f142d82", + "bytes": 18007024, + "build_manifest_sha256": "5dc971338040936af662cfc4f64a7b65588c2bb4ce32600386c25f3dbaa93d68", + "elapsed_seconds": 1.3444180419901386 + }, + { + "pr": 1053, + "sha": "dc4e70237eff58916c4eb6990047904536397264", + "tree": "53aa9019b08dded62e1a4f46f556696c60367d32", + "binary_sha256": "76c114987266734b6373a2c95619b261dbc94c10136614f32668c7951a89afda", + "bytes": 18048744, + "build_manifest_sha256": "8737473b961432dbc964be1e0a1a700274192ff23a28af069c1f0b39f7ddec11", + "elapsed_seconds": 19.46090214990545 + }, + { + "pr": 1054, + "sha": "96fa46b86017dc2a79bc97624af9ac98401190ed", + "tree": "377278cb4c6a8c9f2ce2948870b56b4f6bad46df", + "binary_sha256": "e4900bd5e3c9a536c34f0e8ed8b266247fc8d6a5ce6160b30f0f34a3c98d10b3", + "bytes": 18051832, + "build_manifest_sha256": "e93e2ad3d05d503e9438aac04bfa5f1d72bd3229340b4ede22b92d4b4d6b1820", + "elapsed_seconds": 8.383137225988321 + }, + { + "pr": 1055, + "sha": "00d4f84df01e00f1ce2d7c83576ac38b2eb2fb7b", + "tree": "274966cbc41ffe71e5319c4240e89eff2676200c", + "binary_sha256": "6959b59ae033ba63bec93ac5888b1259c18a19079f4fa13f3124d054e0a22b30", + "bytes": 18074704, + "build_manifest_sha256": "d45237c506ca15d905e2ced08cad70960906adffabdfb2e662d4c3acece1df63", + "elapsed_seconds": 12.780953445006162 + }, + { + "pr": 1056, + "sha": "fc2cd316e81d7319aa44912e786e7aad4492cd0a", + "tree": "97a154cbb22375e90f20ff9a1ffee3d6d9445b27", + "binary_sha256": "864541384da6387a3739dbb68d3e2c6f4991577bd9121cc0a1e6b5cfb610095d", + "bytes": 18101888, + "build_manifest_sha256": "008c91153f66901cba3ad6a8057078ee7b8cb2d25f78e07d928306c002bb5308", + "elapsed_seconds": 6.9507035471033305 + }, + { + "pr": 1057, + "sha": "6bebe940ba36328a399461a19434bf627118bf75", + "tree": "8a40c3ee2d33b5a0dd8d21a8a3a574b8f8d8873a", + "binary_sha256": "09b5ef5656be28c6713ee4279b8727e1a69592c4b60a00c32729dae9a2a8ff5a", + "bytes": 18108104, + "build_manifest_sha256": "89b507110977aed0a1130d768178edf20f04aac81330e356a58c1f7aa3cbde11", + "elapsed_seconds": 10.420100728981197 + }, + { + "pr": 1058, + "sha": "c004bcc65f16df2a264fd5451e4bc7262fecd137", + "tree": "9b06c5f902ce99a874790636ae5563b673e5aa9f", + "binary_sha256": "09b5ef5656be28c6713ee4279b8727e1a69592c4b60a00c32729dae9a2a8ff5a", + "bytes": 18108104, + "build_manifest_sha256": "481934bd044c183e3d43cdea0c685ca6d92697b5f60fabb34b6f546e1264d7c7", + "elapsed_seconds": 0.5378182909917086 + }, + { + "pr": 1065, + "sha": "4b823112efb377658029a2a3d5c4c51594f03e25", + "tree": "449081960d5c525809cc9c09013a90247d0be304", + "binary_sha256": "0bca5ab00ae76832cc19a46f96081f3643bf9e0b273f1803c7b634de5d3301d1", + "bytes": 18133944, + "build_manifest_sha256": "e7aaf4253af38efc97354cc344e6f82590f4b47f819ded808df2a6057654b100", + "elapsed_seconds": 13.693071934976615 + }, + { + "pr": 1059, + "sha": "22702c34a0bcb261238af40f82818369fa46a4ab", + "tree": "51afbca10bd688df36a749077b545ea838f5f1f9", + "binary_sha256": "9a275ed5de577776d17bd899871d187096bd9755ce016a8b8cdfb92be2b94f9a", + "bytes": 18143840, + "build_manifest_sha256": "0c53656f76b32a9af9dccc7fc26fbe015373c94b60eadb9ac66d03278f72ef4e", + "elapsed_seconds": 7.3917549210600555 + }, + { + "pr": 1066, + "sha": "09e6bbfff3275ed36eba7b98052cf5d0877d94f7", + "tree": "d48ae72e7db0a536c723fae872f43ba6954b3cbd", + "binary_sha256": "c21c424a876f82db3ac4de2458c8f47b5161dd49271c1b739f2d1ac6ee0f689b", + "bytes": 18147504, + "build_manifest_sha256": "8b7989ed8faeb6502fa87d193aac84f602bc2a3c5a9a70bd9e71e6345b932414", + "elapsed_seconds": 2.699885717011057 + }, + { + "pr": 1067, + "sha": "fb726c946063d567320d76f2f3d706f0a0997e57", + "tree": "21d04649207d9a1c39c246110764377d06e40b2b", + "binary_sha256": "d865890df4bca87787098ee4f713046122dddb91687d4057eeb3943896b9ba00", + "bytes": 18146176, + "build_manifest_sha256": "4de16834f867b6fb9e49cc1b200d6d3a29fe6f1023bcd8b452798778bf36cdaf", + "elapsed_seconds": 13.449358890997246 + }, + { + "pr": 1068, + "sha": "58ba30eeb90499f50e98da480b8d965047352b1f", + "tree": "5b16cf4b70072e84a76e3a25db35c1badb69ad7f", + "binary_sha256": "59bc370e0204b140ae350340478b23d468cf01801368fc12995afe7d4ab5a294", + "bytes": 18148600, + "build_manifest_sha256": "43dcb049deb159ee276f050ed49b560979965d39d61415ec33483aae897b7c60", + "elapsed_seconds": 2.8365641069831327 + }, + { + "pr": 1069, + "sha": "6d6a2c9abf972ffffd064939381a1df2f40c2776", + "tree": "30a4efaaf6deeaebfde08d81204dfa7584a9e58a", + "binary_sha256": "25a7faf2cf280317b69710082ce7e4c136915f4569358338adf766da98e07bd9", + "bytes": 18159248, + "build_manifest_sha256": "bfe3eda2917bf39c3a84f519231da5a856b05f11c1129da2f1b087091d730a2b", + "elapsed_seconds": 2.8984912980813533 + }, + { + "pr": 1070, + "sha": "44e7e30102eb6c6ae122135189b6c62340c35bdb", + "tree": "08bcccc80d79b6f446256dd1baeb7a2e57158031", + "binary_sha256": "3a35204ebdb657a1ec5682614544f02a594fd0ecd95d92cbf59c88f5b5b81de8", + "bytes": 18155792, + "build_manifest_sha256": "6a9a91506f8058f10eb2c2bf5810548eff8bec64144c30bc34590bfea68ec742", + "elapsed_seconds": 13.00192386098206 + }, + { + "pr": 1071, + "sha": "79f8b371480551c70654e1e83712ebdb6539ca0a", + "tree": "a98abf82377afbd5b19186dc3f0124f0dac2f244", + "binary_sha256": "28d542f2fdd9fab3f0eac7fb8711f52fca8420ab5b92bf5a56481e0fdb821c01", + "bytes": 18162504, + "build_manifest_sha256": "cd6d683b78025ac153eb16472b2e065a2232245b9a17bb22a512c30acf728919", + "elapsed_seconds": 21.61491110199131 + }, + { + "pr": 1072, + "sha": "0fe856d76f6583c3a0023cf6f8f5654bf949bd40", + "tree": "5b0ad27942bad9f997abcf2fbfc2b81a37d1e1b5", + "binary_sha256": "359aa45d3671678d2dbdf721bb85a7ad4636439185b31da4a76106fd556d1e73", + "bytes": 18166976, + "build_manifest_sha256": "dcae803b3a6776e9afde500b6246430167711dabdf415227c3cb5140c0d0dc91", + "elapsed_seconds": 11.150577696040273 + }, + { + "pr": 1073, + "sha": "6db2de9e49f19107f49e257486b50694a764cf23", + "tree": "80a275db32e569e22e25753e890d11b0a1870d93", + "binary_sha256": "45b7e4b3fc457faaf59f6ff08a7d64ed7361e304ca2ae129b9143ab4081ffbb7", + "bytes": 18165496, + "build_manifest_sha256": "474c3f8a8e7e736379a2ca07c8fe2489a6aeb5627c51660710850f4872ad2fdc", + "elapsed_seconds": 11.49217546696309 + }, + { + "pr": 1074, + "sha": "7173ffcbc66063560d31e04fdd58fa4a1c6ebe8c", + "tree": "a53827903ac4ce358849affb6535e039fc704368", + "binary_sha256": "45b7e4b3fc457faaf59f6ff08a7d64ed7361e304ca2ae129b9143ab4081ffbb7", + "bytes": 18165496, + "build_manifest_sha256": "419bd7f6b0408c14e083adcb99a4533635bbfba896140826ecd11866e7a4793c", + "elapsed_seconds": 0.5873665800318122 + }, + { + "pr": 1075, + "sha": "62400cd3b12ec42c2b1aa7dec049c2510cbf456a", + "tree": "1f1d5419370d5e1700a63802523f46439c4b8001", + "binary_sha256": "b2aea9a648da6563748aaa9983276358afa680b6f38eef4a75e48bd64d7a5829", + "bytes": 18220984, + "build_manifest_sha256": "d4c47974a0c7261d23cd6283f5a9f390e95912687ead379e4e3c8915bcc7573e", + "elapsed_seconds": 14.046104717999697 + }, + { + "pr": 1076, + "sha": "653f5ed25b68e84e0b292afa9671289eade3b534", + "tree": "9c66b5e05a9c091dfe78c0d3b58ba01f0696fea2", + "binary_sha256": "c9bfb9fdcf30b1b41402032c785e243d3a602c229893b573ecc7d873dabce994", + "bytes": 18220928, + "build_manifest_sha256": "9706f6f2e5a979cc4c5d9eacdf548eb5dab28ce37cdbcf64a9e5f9e88b47bcb2", + "elapsed_seconds": 3.2822915519354865 + }, + { + "pr": 1077, + "sha": "35b810bb806aa169c075c01a449a408cd3758248", + "tree": "a6146c044af7cd1b39c7be5e31f84becd0f3a406", + "binary_sha256": "4996cc3367d09beeb73b1b8f048edf008dd44bdebbf6d6a0e9ba205dd53675d0", + "bytes": 18227152, + "build_manifest_sha256": "5f052d9c0c6c3aca1762b227ad7a02f772de140306ca3ce254e3dfc28e740572", + "elapsed_seconds": 3.243145783082582 + }, + { + "pr": 1078, + "sha": "76054b3a9c60baa72afd0452bbc3ac6bc2f79efd", + "tree": "0c9538167ba1badb64a5b59f708def754a3e3571", + "binary_sha256": "4996cc3367d09beeb73b1b8f048edf008dd44bdebbf6d6a0e9ba205dd53675d0", + "bytes": 18227152, + "build_manifest_sha256": "861bd7165727ea49dc11c0235885e2379b038bece177ba5febfcf2cf2524009c", + "elapsed_seconds": 0.59876661200542 + }, + { + "pr": 1079, + "sha": "01ace14aa38a87db7d2f1441043cd61cf0b3de49", + "tree": "9aad351fa68ff0bc4bd3d9b7929a28c64bdc477b", + "binary_sha256": "21a1d76b433bcb044ed68bdec87cff6bc6f5c6ed62a0b314af29eedffbcaf9b2", + "bytes": 18270232, + "build_manifest_sha256": "94df102f24904ca41e2b846bd27ff4539ae1970b69ef5f8f54559621e4d19e1c", + "elapsed_seconds": 12.942402977030724 + }, + { + "pr": 1081, + "sha": "0d64bb3974f4e70bc5dfc36ea8647e7e7db3cbf5", + "tree": "21538b2036e45f70f4ee19eb830b1795f1563db7", + "binary_sha256": "21a1d76b433bcb044ed68bdec87cff6bc6f5c6ed62a0b314af29eedffbcaf9b2", + "bytes": 18270232, + "build_manifest_sha256": "bbc552883d3d2c1cbc2d82fa628a247f179343e76523c942e1ea69e87eaf6d2e", + "elapsed_seconds": 0.7398356680059806 + }, + { + "pr": 1080, + "sha": "669f68a3e26303c06325c6beaee44019481bcaf9", + "tree": "3c7877e2726cf4a92a2ba7b1313a352c478b492b", + "binary_sha256": "2adb143197de9c962db58eebddb13ea7fccbd4b4f351d93c458f24fb19a05f0e", + "bytes": 18266440, + "build_manifest_sha256": "81def9ade126c6eefaadb7b1a46b4d586342a96160a20d8617188a23bff4f02a", + "elapsed_seconds": 7.668271848931909 + }, + { + "pr": 1082, + "sha": "6e6b25ffc8696d6d28867a1ee6ea2e9beb00a77d", + "tree": "7a6a2a483889a0d425f958058a4bea442867c646", + "binary_sha256": "7334900ac8c0b146a7a83085cd59dde8ca43d90c00d885ef5f05c8dbf18cc335", + "bytes": 18269920, + "build_manifest_sha256": "f74aeea6ebf27bffe78bd941ee6f4a3c3764d65b8ec330ea13592b4f7779c8c0", + "elapsed_seconds": 11.152501000091434 + }, + { + "pr": 1083, + "sha": "f9a73afa1497589b49f33c99c49248adf3a7b38e", + "tree": "638ab13f27de3cf6865c7299e0be2be303007402", + "binary_sha256": "55dcb5583dc8495c9c0cc6313b91633cfc39fb482fe958cced09fbf67cc2ae97", + "bytes": 18270952, + "build_manifest_sha256": "5c032399213404110dd883e337a3413f0dbffd31592bbb584ee18ae85ba9f056", + "elapsed_seconds": 3.0343299090163782 + }, + { + "pr": 1084, + "sha": "f06cea15f5b1b0b04be246501c894b79782eb0fd", + "tree": "09d97ff49a70b6749935f03db44c90a86c798339", + "binary_sha256": "b9e8a1324fd5b103a16b29db14b3ee7694ee5ca59bb77e24d468737daa8f8c0d", + "bytes": 18272872, + "build_manifest_sha256": "249f1d37279d4ccc9fcb8da2288f104c50bb9938586aa538f276e3a7c39001dc", + "elapsed_seconds": 28.99749979097396 + }, + { + "pr": 1085, + "sha": "790dd72d400f7ac3e8656ea48c7ba718b41badd2", + "tree": "bb6b3ad4ee5324e647adc13bb4f92573bb4b7ad4", + "binary_sha256": "463cc571bb34f28ba628a72f7adb72249e48cd97e0c85494bf28e536b38fdaf7", + "bytes": 18273560, + "build_manifest_sha256": "9824f260517cf157be7fc38ef16daf5ff17d1e2960597d003bd51ce51f7c70bf", + "elapsed_seconds": 10.145889680017717 + }, + { + "pr": 1086, + "sha": "ba9b2baaf8d7ed7a7ffdeac7a16bd63f43255071", + "tree": "05f2ef2df47d5062d39f257d541d5663a0fc33b5", + "binary_sha256": "c573b611d41d1e73bf0726798d90d2902a9b460b73c9c82f34709bd31a3a9074", + "bytes": 18276792, + "build_manifest_sha256": "ec92b520d3c11d2f512b5a4d422073ff211c045562b55bdd34a6006a1d5e8933", + "elapsed_seconds": 9.965236848918721 + }, + { + "pr": 1087, + "sha": "f7bdc5d248e76a54278aef5030c0a3468505bd2f", + "tree": "9bbcdac4026dbb5e13e70fa942650c8c715a81dd", + "binary_sha256": "9b365baca898a0ea1939d3f57ef13dd4318ce7451e367439ebd31da8253bb2d9", + "bytes": 18269792, + "build_manifest_sha256": "2722e9678ed89b79fbdfb5fe337b205f0873f602d3479838dd3ca0ac6df3f396", + "elapsed_seconds": 10.308180430089124 + }, + { + "pr": 1088, + "sha": "9bd70fc9b4607cd8a586615c630706f85416e62c", + "tree": "e35d6b499427c1183749171d17f91f36e9612bd2", + "binary_sha256": "8617cc1e3d88fb79351528c08539c3695877313da833148210142efe7100bdc6", + "bytes": 18322944, + "build_manifest_sha256": "96187eb27d6683a07b7eb0c6726fa5628075500d8d820119acd6d3d6b2f60790", + "elapsed_seconds": 11.333163599018008 + }, + { + "pr": 1089, + "sha": "bec36225c686b58914e8ab9792e822d56fe1ef07", + "tree": "980272b2bd286608ecd915e25903cfbb1a489f36", + "binary_sha256": "be23c1ba04f25e638ca47248f96c496ff66a5755873775a37c841f9253adb39a", + "bytes": 18318168, + "build_manifest_sha256": "e9c02514a718f2c640a43c62d9829fb6043d406a2a0e4e693b0541a9c23d1208", + "elapsed_seconds": 9.878176280995831 + }, + { + "pr": 1090, + "sha": "798c2c0a3b4f9c1acfa050f2eac1b8902ba89ae8", + "tree": "b2d91193364e7e28e97cc2987d2ffa6abaa4e76b", + "binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "bytes": 18357984, + "build_manifest_sha256": "699a490192006c29df261db93d5ae26b3e4d64f33ac4e6060d87f0bdcc144a56", + "elapsed_seconds": 21.027587598073296 + }, + { + "pr": 1091, + "sha": "e66bdbe1097f4a051580dcbb68d17e745ec5e9ba", + "tree": "b0cb708273a7a80b36599f8de6caa01a6f209146", + "binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "bytes": 18359008, + "build_manifest_sha256": "82f64f5c82cea971fcc613a02416ddfda6b8dd0f91ccc2cd2733dfb138443a66", + "elapsed_seconds": 21.734148474992253 + }, + { + "pr": 1092, + "sha": "a89459ed819af4fa6841a9ab7eca4e554949fd72", + "tree": "2705ce1ea2d779f292cd6f8c5f6706d1e5d809ec", + "binary_sha256": "5cbcac47a68ede4ebd8a08e416d7438390d85686b2148c7bc340cd2606fac466", + "bytes": 18370664, + "build_manifest_sha256": "2bd389d29b8c26961b2e85f052238e905d49ddf2b6f0fee6633d34f97b6bfa28", + "elapsed_seconds": 9.307812692015432 + }, + { + "pr": 1093, + "sha": "a7a6125a9358f1020fc914d6c91bbf8c6e66392f", + "tree": "f4da502d59284999ce58ca50a22bd015858fb371", + "binary_sha256": "5cbcac47a68ede4ebd8a08e416d7438390d85686b2148c7bc340cd2606fac466", + "bytes": 18370664, + "build_manifest_sha256": "4790a9fbebdc68148207018849bdc8a6c3dea62767c1ee3932649792a8f96d9b", + "elapsed_seconds": 0.5221935050794855 + }, + { + "pr": 1094, + "sha": "bb0185a0379075480eb8b1499f5bc5ff8cfafaa8", + "tree": "9080f091d6029b6afc54bd7d455108dddd98eee0", + "binary_sha256": "a0ee28a35b0fe2cc3a9fc0f8a476cc9629dc63557dfb14a5f98beae405d58a95", + "bytes": 18398856, + "build_manifest_sha256": "2868a55d4cf09515eacee2c14f3c8dfcc79eab921ccd177e2b5fe49954e35b6a", + "elapsed_seconds": 10.294123527011834 + }, + { + "pr": 1095, + "sha": "6792b5030de70a737dec2878673aebaa6ddc57af", + "tree": "826b394d04a0c709e5a67c46ef1f48bcf3c8bbd4", + "binary_sha256": "e5e8828e1e7211fbec191238e8dca34929c19c4060d20643ed60c939cb3d52bd", + "bytes": 18401176, + "build_manifest_sha256": "4f8b4a43efa2bf040a7acf5cf58ee6acbd00347ffd3b320a73f549b2f2612c12", + "elapsed_seconds": 5.489695476018824 + }, + { + "pr": 1096, + "sha": "39282994e036bb4dc43c2ca9ffdb2a2f498bb99d", + "tree": "400bdf2b0ac576947d8f5407615485d7a7c675c7", + "binary_sha256": "6d6a630237d8f7112838417b243f037cab992795c7ccc452ed38b9e102446e32", + "bytes": 18401048, + "build_manifest_sha256": "bfbaad5cc2c50eed8ded7530f01605f604beb2feeb20422262588bb15c8d7495", + "elapsed_seconds": 4.786088038003072 + }, + { + "pr": 1097, + "sha": "910e2a7bbae50a3562135784d56e2ba903e89e7c", + "tree": "1be2f889ab19f8f78fd8124c0744c78741c7936d", + "binary_sha256": "6d6a630237d8f7112838417b243f037cab992795c7ccc452ed38b9e102446e32", + "bytes": 18401048, + "build_manifest_sha256": "3068a9377292e0b19a4ebc5dc418366b4f0e20cb40f81c7f0b91f952f23c2f4b", + "elapsed_seconds": 0.4534852768993005 + }, + { + "pr": 1098, + "sha": "7c8cd64e02a84ce13f5a7d3b3dd37290307a40a9", + "tree": "1a4c9b6198d7d78e24c3578708421e31effa364e", + "binary_sha256": "ae9519a93d7479940339272dc57ce7491321fd41b8c6a9b5600bf34c3388df5f", + "bytes": 18404960, + "build_manifest_sha256": "e622ba75e2fc5e43a29b7ad20e709ff9d7365d9ab179a109be21e3a7eff8e47a", + "elapsed_seconds": 7.221381574985571 + }, + { + "pr": 1099, + "sha": "76185cb37fa2d4f6cb36876efde58b0ede0e753a", + "tree": "dc0498119edca8ea33c29f4ffea88bbe76cd18f5", + "binary_sha256": "ae9519a93d7479940339272dc57ce7491321fd41b8c6a9b5600bf34c3388df5f", + "bytes": 18404960, + "build_manifest_sha256": "9d8897519a83df75e53cc3849390825146bb059d31b5f56c6ac260dbdb893c66", + "elapsed_seconds": 0.5722937639802694 + }, + { + "pr": 1100, + "sha": "57e9287e675f180ef6a7b0cc5d4e883605b1bfdf", + "tree": "22fce681966d777fcc583edd6256bfd6e93be6a3", + "binary_sha256": "ad9fa9caf403c653c4101add1657b01bafc6d752949eb8c96245f7901376db54", + "bytes": 18431008, + "build_manifest_sha256": "23e9a06e9b99ca4d9e9582a95c9b3298b6783c335cac5d19de47442a39cf2e78", + "elapsed_seconds": 29.027532430016436 + }, + { + "pr": 1101, + "sha": "318edb2f60ce1a9a526fc94a15ea7cdad4c4d181", + "tree": "9fee73c833122f2635772d426c90bda4b0ebee32", + "binary_sha256": "f09cec12b0fe68fe2840295a050208557ce13955e8b9f6543331a07731867f33", + "bytes": 18430320, + "build_manifest_sha256": "522439242bdb33d5f1f0856596c8316819d2a09defd0f3f359a5759e5d30bd7a", + "elapsed_seconds": 25.26812796201557 + }, + { + "pr": 1102, + "sha": "55ea67e3f06e5055b43d8cb780661901731592f2", + "tree": "412786b2ddbfd24b3138891ae823f25748d03d76", + "binary_sha256": "f3601f70bafd458aa495ff187c2b9428694eb53085d1ae94348ba5b0ee7d455f", + "bytes": 18429056, + "build_manifest_sha256": "671f4a4c0fe749b7ef2df2224bbe1fe53cc403836fb7abb014db247b671e5e48", + "elapsed_seconds": 14.137501891935244 + }, + { + "pr": 1103, + "sha": "f3ec0faf7a1bb16ddb0b3b8bcee2c3e5bd970df2", + "tree": "8498213520d3cb2480484e33259b2eee3e075369", + "binary_sha256": "f3601f70bafd458aa495ff187c2b9428694eb53085d1ae94348ba5b0ee7d455f", + "bytes": 18429056, + "build_manifest_sha256": "932ef029851c333929566daae63cda2760acdd48641c7b925105c475df0a1f57", + "elapsed_seconds": 0.583538148086518 + }, + { + "pr": 1104, + "sha": "455dcd8eb5dd98b09f3117f5316136b6d43cfd8e", + "tree": "e0ede615f8ea55c7ed6177a34a1044d4413c3391", + "binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "bytes": 18429168, + "build_manifest_sha256": "24e303593556018b4f5d70c2e301fd73fd656063caf398936b2ff6fda1976ffb", + "elapsed_seconds": 3.9156571510247886 + }, + { + "pr": 1105, + "sha": "245e74ff6cbe6c0f84a074be669c60ac7cbc5e8f", + "tree": "2e172367b2730eae8c71ae99d357f21ed390c578", + "binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "bytes": 18430944, + "build_manifest_sha256": "136077d0e141c233e51cd7f6cabd53dd71e06e2074b01e36267e22c3f59cd61a", + "elapsed_seconds": 7.714408111991361 + }, + { + "pr": 1117, + "sha": "b60cf7a5a92609f9fadddd4759d3c55e755a69b6", + "tree": "14fe3d589243ffb7405d3c0fc7efff1db2d73890", + "binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "bytes": 18430944, + "build_manifest_sha256": "5757ca29d9ddc5f9d3db48df51f84f25493d9b1937ca784751a7a5d0e46b4975", + "elapsed_seconds": 1.3547864980064332 + }, + { + "pr": 1106, + "sha": "e7e42d01e0678590fc06bd90b9143682a84aef7d", + "tree": "9e90c6675a556ece1a98d4c983c9b3a24fb12b21", + "binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "bytes": 18430944, + "build_manifest_sha256": "235a9669c198f97f5aa97333855f0146cdb40a2838a05c3fc145be4d9f9688a5", + "elapsed_seconds": 1.3107601060764864 + }, + { + "pr": 1107, + "sha": "ccb1f0a202ed59b30246c14e424a400e47acc447", + "tree": "4ee726582ba06ca39e33a1307d6242f1a99680a8", + "binary_sha256": "3191e15d43978dbf7602e3e350592fae8d72539e620baf069ad5daa3052f5512", + "bytes": 18431464, + "build_manifest_sha256": "d7b04083a5303a566608cba562d2474f1a602727f8e3d0f58e31207844a4a961", + "elapsed_seconds": 4.062736371997744 + }, + { + "pr": 1108, + "sha": "adae6c9cd98bdd4b15f7b2867d08b1bfe12e1fad", + "tree": "3825f364cfe423e6612d859f23a0a928bb59a843", + "binary_sha256": "735cd1d468c2fdedcb2ad66d206aafa76b5ea1acc05ac2850a455f54362dfe37", + "bytes": 18435008, + "build_manifest_sha256": "a4efc9b13e3b94b14b0a36b74f54ff95a4f8a00e1ab8afbff78b1080799ef484", + "elapsed_seconds": 8.316323721082881 + }, + { + "pr": 1109, + "sha": "a1ff80a81c1ff2c4fd93898aeaf07dc2fc5764ff", + "tree": "a6d0ede96193f3807d07c8c301cf48007daf2b1b", + "binary_sha256": "735cd1d468c2fdedcb2ad66d206aafa76b5ea1acc05ac2850a455f54362dfe37", + "bytes": 18435008, + "build_manifest_sha256": "cebd9d16fc0732155a688b3437cc96df383403928ea9c23609ce825c9e5d7998", + "elapsed_seconds": 3.6257614200003445 + }, + { + "pr": 1110, + "sha": "e9bebfa5bfd85137de756047795887d45248ec18", + "tree": "30f9b479d62fca27aa43268f86ede8ac074e9317", + "binary_sha256": "735cd1d468c2fdedcb2ad66d206aafa76b5ea1acc05ac2850a455f54362dfe37", + "bytes": 18435008, + "build_manifest_sha256": "ba5d25828a8e21fb9a29608137f57cdc0ec5b61d81c61fc2c183f33272498732", + "elapsed_seconds": 1.1849576289532706 + }, + { + "pr": 1111, + "sha": "5cade08b6701417b07343b12ac86331ed0c3b941", + "tree": "0730bfa094800b4ee8c660f177a947dc70e27ca6", + "binary_sha256": "735cd1d468c2fdedcb2ad66d206aafa76b5ea1acc05ac2850a455f54362dfe37", + "bytes": 18435008, + "build_manifest_sha256": "d7a4a10e04d7d9ae9cbe7c424c43901fb79b549f603de8e1c895e2c854e75002", + "elapsed_seconds": 1.1666911960346624 + }, + { + "pr": 1112, + "sha": "852539d084ca1c4bb1756b0f83eb4b50b2b19b85", + "tree": "39c37ea306fe0a715df186e7c913f33e9b9bec45", + "binary_sha256": "735cd1d468c2fdedcb2ad66d206aafa76b5ea1acc05ac2850a455f54362dfe37", + "bytes": 18435008, + "build_manifest_sha256": "18b03082518571a51aecd919934d21adc524b99a1c3625b75e3ef00d230db929", + "elapsed_seconds": 1.3060865430161357 + }, + { + "pr": 1113, + "sha": "5729026a8482a2bc331058ee658017f9aba74298", + "tree": "770f724c2288249321b02a59e5e8ba6916e2ba07", + "binary_sha256": "63403a74dca040a3d9a2485eb9888cb73e523929ff70b27d91b7591fd9ffa616", + "bytes": 18437376, + "build_manifest_sha256": "562e22d915e9180e541b93784576a7638eabd489851683f253f43cb009d9e41c", + "elapsed_seconds": 15.421961409971118 + }, + { + "pr": 1114, + "sha": "713abe5fa302c9ff78e7df769304f90379566c83", + "tree": "6d576d684c72aaa9980f7c837ff226bc1a64eaa9", + "binary_sha256": "63403a74dca040a3d9a2485eb9888cb73e523929ff70b27d91b7591fd9ffa616", + "bytes": 18437376, + "build_manifest_sha256": "7f1263f976023f0e4740d500efa1dc56991b13ac143887e69acf32514b46585c", + "elapsed_seconds": 0.5478180759819224 + }, + { + "pr": 1115, + "sha": "ab909839da7d1ae34ea63eab75ec83dc62fd33fb", + "tree": "b658839bb7578d24067f614682ef477b81278750", + "binary_sha256": "63403a74dca040a3d9a2485eb9888cb73e523929ff70b27d91b7591fd9ffa616", + "bytes": 18437376, + "build_manifest_sha256": "e05d97e79261e2e7e40b28480557a6516efc047470bad84f900450bbaf5df8dc", + "elapsed_seconds": 0.5984248570166528 + }, + { + "pr": 1116, + "sha": "f4cee33eeb6b6cf00c1b39003b11fafbb262f79b", + "tree": "683b31abb1e355df334aaab2b7c952885429b319", + "binary_sha256": "98a854db9dd1ba23ffdf19206ac4fbe513d07247a258d43bf00f69b958472c9b", + "bytes": 18437472, + "build_manifest_sha256": "feaf4cec506e02a4cfabd658b87f3bc5c7401b3d5c712675da0ac299740b030a", + "elapsed_seconds": 4.054585766978562 + }, + { + "pr": 1118, + "sha": "c7bb70cc6f3e6441ff25c999667d76f48ffe9acb", + "tree": "5eb723ea3b680fbf265c86f38704cb80faa6344c", + "binary_sha256": "c819fcc39a0f5546f014c74cbd82e9acc3f86ae5b5828096166d6d8c03ab95d8", + "bytes": 18433032, + "build_manifest_sha256": "caa706b8f27b60f35bc963720459ecc042ec5a1564d2600110f90309cce771ce", + "elapsed_seconds": 7.176634239964187 + }, + { + "pr": 1120, + "sha": "2487927cc6b1de326ea3c6c058dc493214354bec", + "tree": "60f195e5486e3dea1c6e19656ec7d860eca81fa6", + "binary_sha256": "15d7ad5ca6686d5cdf5442619624eb3850ce67ff0e5cea810610f5ff97b3a986", + "bytes": 18433920, + "build_manifest_sha256": "497deabd0953226c60624def54d2435d6ba0ce51e8fdbccee2f7a726b2a86c8f", + "elapsed_seconds": 7.691392004024237 + }, + { + "pr": 1121, + "sha": "d9bf84b04784daf1d457a213f2dba277ba32ed2e", + "tree": "65b2ace97b2602c67311449144201b0b5760913a", + "binary_sha256": "b662c1321a36ea45ad4207c98c3ed12621ecfe900a9060dde15c20cc5b327f61", + "bytes": 18434440, + "build_manifest_sha256": "211b9e61bfcb48a73cc54856a2f688c4296b6829a932079c991bc68f85ea0331", + "elapsed_seconds": 4.223810734925792 + }, + { + "pr": 1122, + "sha": "0e95e191ba7d7ee3769217e7fbf82a825ff9b90d", + "tree": "ac81b90e6759936f944137f074a6592a93c602d8", + "binary_sha256": "e158875175cb7ad64747911d69836842ac1079ac907412270a15b3f090eaf0cc", + "bytes": 18433048, + "build_manifest_sha256": "40593e8322693a4374bb6a18131372e2d4fc10dcfeaa879f565c02953e118167", + "elapsed_seconds": 33.68569688498974 + }, + { + "pr": 1123, + "sha": "83657b9dfe35adda2a4cede5a1ae71db2f2b870d", + "tree": "8757d218ddd469cf8d6da0412aaded21eea89842", + "binary_sha256": "a0679789c7e76a09fca6efe356fa541a2bb87f174d76b3bb64217b2065d55360", + "bytes": 18443440, + "build_manifest_sha256": "0848c12c804894c8e9f812b8b5005f9b619734af425c7548a6e8ed83cdd3b06c", + "elapsed_seconds": 14.271701524965465 + }, + { + "pr": 1124, + "sha": "de2fa3557d69e9c3eb1c52bb2b0300566f960fea", + "tree": "0372118af04c8b28e400ac2c42e7770a8284f1ba", + "binary_sha256": "a0679789c7e76a09fca6efe356fa541a2bb87f174d76b3bb64217b2065d55360", + "bytes": 18443440, + "build_manifest_sha256": "812f145bf64b9ae4b6b4bfd612a78608535e616aaa0360d62c41cd82a9882ff8", + "elapsed_seconds": 1.279053537058644 + }, + { + "pr": 1119, + "sha": "c95140674254c371844f1fab27a64951a80dac55", + "tree": "0c84c52edb72e1a8643e95d3f8d9c36cfb9c2b28", + "binary_sha256": "ba18f774e9f8d8f6cfd94efe211de305bd260f474e42ad3bbcd1a785aec0d296", + "bytes": 18443224, + "build_manifest_sha256": "2a5da319876b666b4e6abd29de17927963e52e975749ffa3d6ad958e64e35c0f", + "elapsed_seconds": 17.982304272940382 + }, + { + "pr": 1125, + "sha": "9bf1aad510d843d1d6338fbdf23107a30d339730", + "tree": "6773b29582bfd9a3cfa725d38334b845e6fb1884", + "binary_sha256": "ba18f774e9f8d8f6cfd94efe211de305bd260f474e42ad3bbcd1a785aec0d296", + "bytes": 18443224, + "build_manifest_sha256": "b19b7865be68e8d41fe93d4ce9edb25bd81e6526227fb52f637091b0ae154232", + "elapsed_seconds": 0.7968119849683717 + }, + { + "pr": 1126, + "sha": "d8cf61cccd4b0efed5058bf6fa45228e47162b48", + "tree": "d107bd98d9654a1d3697eb7908c3c76eed4b6233", + "binary_sha256": "ba18f774e9f8d8f6cfd94efe211de305bd260f474e42ad3bbcd1a785aec0d296", + "bytes": 18443224, + "build_manifest_sha256": "92f3ba8fcef0231e5f99b7690b916e436f60d0fb859e7f18ae0228750976d307", + "elapsed_seconds": 0.48625714995432645 + }, + { + "pr": 1127, + "sha": "1786340680499f50b08dee5b1ceffbc20fd7b533", + "tree": "456fc02247f3cf07dc393d61e59f70fc1c1dc977", + "binary_sha256": "69e80167ac5c8b2dbdfa9b7d6bf5299f6cc80c3278d3ead8d43fd6e228fb52c2", + "bytes": 18454496, + "build_manifest_sha256": "cf3c58c13b21e11b3c9f9d6cac493b712eca4a66ecd1353530ebc3375e435fc2", + "elapsed_seconds": 5.283866641926579 + }, + { + "pr": 1128, + "sha": "1278c8943a6abd236a2f20e3937cc8e23a0f95a7", + "tree": "26930342e34ce0b0899fcb3f1be0ac24511a5d58", + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "bytes": 18454184, + "build_manifest_sha256": "0aba68b2924a9ab2343f943039469103b365265276db98ad0a6857a9217f6b45", + "elapsed_seconds": 0.529834948014468 + }, + { + "pr": 1129, + "sha": "77aa9ef9bc9475adcbdd37cf3004143a96f03060", + "tree": "2c38d1117a95c987657d8deec8e67a932b35c896", + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "bytes": 18454184, + "build_manifest_sha256": "22231534e596a4049a656363d74312b667deb66b061e58998e06ee366c26726a", + "elapsed_seconds": 0.43361345201265067 + }, + { + "pr": 1130, + "sha": "ae8c5af3eb11dc8571f11db9b307b0db948f78c6", + "tree": "3950c87709136624ce54188a8d9afb38d48854f7", + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "bytes": 18454184, + "build_manifest_sha256": "b2047fd05cf98338b40681258b1b48bcc8c5b109865247cd7b92b45b37467008", + "elapsed_seconds": 109.87988504196983 + } + ], + "accounting_launcher": { + "source_revision": "ae8c5af3eb11dc8571f11db9b307b0db948f78c6", + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//tools:process_resources_native", + "--config=clang_opt", + "--jobs=6", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//tools:process_resources_native, target)", + "--config=clang_opt", + "--jobs=6", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/tools/process_resources_native", + "sha256": "c8822009aa8b2eb0505a6c883d452c1834efab732b1104b58ab67b998b246df2", + "source_sha256": "0b72ffc7b767682dca724bb6d8de8b5f2ccaae532b5b99c9e14f68505769a010" + }, + "installed_dependencies": { + "status": "installed locally", + "package": "/home/marcus/Documents/xff-chart-campaign-20261107/libicu70_70.1-2ubuntu1_amd64.deb", + "url": "https://archive.ubuntu.com/ubuntu/pool/main/i/icu/libicu70_70.1-2ubuntu1_amd64.deb", + "sha256": "223c1e6cebf2a6748637303227d8b84337c14a2d30eacbc46a68d02557dcff3e", + "library_path": "/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "libraries": { + "libicudata.so.70": "68b1442c7bc043896934153e81b40f3b9154628f441739b3590eeae1654495ae", + "libicudata.so.70.1": "68b1442c7bc043896934153e81b40f3b9154628f441739b3590eeae1654495ae", + "libicuio.so.70.1": "b56a951d1cb3379e1129750c8728fc4cea72ed1f48d50a332c38b3fe929a030b", + "libicuio.so.70": "b56a951d1cb3379e1129750c8728fc4cea72ed1f48d50a332c38b3fe929a030b", + "libicutest.so.70": "adb32cde4fc5764fc9d67b9538434ecee9cdabfd8bf51179afe2b8bf4023156a", + "libicutu.so.70": "d2c53127b32b637cb088077d9dfa9e4ce283b1d1d78db5f394fa1b218bd39a9d", + "libicutest.so.70.1": "adb32cde4fc5764fc9d67b9538434ecee9cdabfd8bf51179afe2b8bf4023156a", + "libicui18n.so.70.1": "400b4ac2b04121b9f0b8bd5549086491a3d72435d3217190f8767b4fb0080e3d", + "libicutu.so.70.1": "d2c53127b32b637cb088077d9dfa9e4ce283b1d1d78db5f394fa1b218bd39a9d", + "libicuuc.so.70.1": "b62ce27b7f7036d6bee15086f569271239fe5d46ef5da7535acf32e5e5e80b7b", + "libicui18n.so.70": "400b4ac2b04121b9f0b8bd5549086491a3d72435d3217190f8767b4fb0080e3d", + "libicuuc.so.70": "b62ce27b7f7036d6bee15086f569271239fe5d46ef5da7535acf32e5e5e80b7b" + } + } +} diff --git a/docs/benchmarks/extended-history-complete-audit-20261107.json b/docs/benchmarks/extended-history-complete-audit-20261107.json new file mode 100644 index 00000000000..6d7af8e6920 --- /dev/null +++ b/docs/benchmarks/extended-history-complete-audit-20261107.json @@ -0,0 +1,43 @@ +{ + "historical_arithmetic": { + "checked_points": 93600, + "verified_missing_points": 31200, + "max_error": 1.1102230246251565e-16, + "complete_revisions": 130, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "2c3923ad84f30162321f7af4031e89d7b5b04d21b095071d478da37ab298fe89" + }, + "confirmation_arithmetic": { + "checked_points": 1440, + "verified_missing_points": 480, + "max_error": 1.1102230246251565e-16, + "complete_revisions": 2, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "627a270f2f748c902b27bac437cb41bf01c335664a3267565a20c426568dd685" + }, + "historical_browser": { + "campaign": "measurements", + "revisions": 130, + "statesChecked": 96, + "errors": [], + "failedResponses": [], + "full_receipt_sha256": "aa199502ec4587aab7adee7473eaec498482999c5e793bb24b4df2e788bbcd48" + }, + "confirmation_browser": { + "campaign": "confirmation", + "revisions": 2, + "statesChecked": 24, + "errors": [], + "failedResponses": [], + "full_receipt_sha256": "b1daeebfd67fd198a1ae6f1cb7dd88ef3f5a114b1d62e6bf528d418998424d82" + }, + "retained_binaries": { + "utc": "2026-11-07T15:39:09.285194+00:00", + "measurement_contract_sha256": "2c3923ad84f30162321f7af4031e89d7b5b04d21b095071d478da37ab298fe89", + "revisions_checked": 130, + "purpose": "Independent post-collection rehash of retained binaries and frozen build/link evidence.", + "full_receipt_sha256": "8cfefbe504c105f0efaea4f9ac1fa84e0372617a88505b89d1eb540891972574" + } +} diff --git a/docs/benchmarks/extended-history-results-20261107.json b/docs/benchmarks/extended-history-results-20261107.json new file mode 100644 index 00000000000..4e085cdf863 --- /dev/null +++ b/docs/benchmarks/extended-history-results-20261107.json @@ -0,0 +1,832 @@ +{ + "recipe": "extended-production-v1", + "complete_revisions": 130, + "history_cells": 7800, + "history_repetitions": 9, + "history_keep": 7, + "history_contract_sha256": "2c3923ad84f30162321f7af4031e89d7b5b04d21b095071d478da37ab298fe89", + "confirmation_cells": 120, + "confirmation_contract_sha256": "627a270f2f748c902b27bac437cb41bf01c335664a3267565a20c426568dd685", + "confirmation_repetitions": 27, + "confirmation_keep": 21, + "identical_binary_control_cells": 180, + "identical_binary_control_p95_factor": 1.0305246976568252, + "aggregation": "Equal-weight geometric means over declared broad/deep and 1/3 CPU cells at each task/size; ratios greater than one mean the numerator is slower.", + "workloads": [ + { + "task": "files-exact", + "files": 100, + "history_old_over_current": 0.9937198763545335, + "confirmation_old_over_current": 0.9848801495554456, + "latest_over_traditional": 1.3723345158690115, + "latest_cpu_over_traditional": 1.711256931384503, + "confirmation_latest_over_traditional": 1.383886514967045 + }, + { + "task": "files-exact", + "files": 10000, + "history_old_over_current": 1.0331069524238312, + "confirmation_old_over_current": 1.0526896199611862, + "latest_over_traditional": 1.351467033185626, + "latest_cpu_over_traditional": 1.4411091180175193, + "confirmation_latest_over_traditional": 1.3495089734221253 + }, + { + "task": "files-exact", + "files": 100000, + "history_old_over_current": 1.0875193168102533, + "confirmation_old_over_current": 1.0946999744351824, + "latest_over_traditional": 1.1501740446244468, + "latest_cpu_over_traditional": 1.1658380098727237, + "confirmation_latest_over_traditional": 1.1588118301083097 + }, + { + "task": "name-native", + "files": 100, + "history_old_over_current": 1.022150441796331, + "confirmation_old_over_current": 1.0177997958395013, + "latest_over_traditional": 1.3713512741467428, + "latest_cpu_over_traditional": 1.7452263753381172, + "confirmation_latest_over_traditional": 1.3789697344025562 + }, + { + "task": "name-native", + "files": 10000, + "history_old_over_current": 2.402370963285849, + "confirmation_old_over_current": 2.6521662559016224, + "latest_over_traditional": 1.2280232419198753, + "latest_cpu_over_traditional": 1.2840793746297743, + "confirmation_latest_over_traditional": 1.2249086247757968 + }, + { + "task": "name-native", + "files": 100000, + "history_old_over_current": 2.6384137377107466, + "confirmation_old_over_current": 2.454037056735475, + "latest_over_traditional": 1.0894594593007008, + "latest_cpu_over_traditional": 1.0971658746768778, + "confirmation_latest_over_traditional": 1.0900224527089997 + }, + { + "task": "metadata-time", + "files": 100, + "history_old_over_current": 0.9741573044399258, + "confirmation_old_over_current": 0.9831019124289403, + "latest_over_traditional": 1.380176488150505, + "latest_cpu_over_traditional": 1.693509900162589, + "confirmation_latest_over_traditional": 1.3726713650614235 + }, + { + "task": "metadata-time", + "files": 10000, + "history_old_over_current": 1.0667656100535352, + "confirmation_old_over_current": 1.0579893783662129, + "latest_over_traditional": 1.2120572535160805, + "latest_cpu_over_traditional": 1.2358245032100117, + "confirmation_latest_over_traditional": 1.2238212088946465 + }, + { + "task": "metadata-time", + "files": 100000, + "history_old_over_current": 1.079929713167459, + "confirmation_old_over_current": 1.082401260810467, + "latest_over_traditional": 1.1406406779958336, + "latest_cpu_over_traditional": 1.1468384141433152, + "confirmation_latest_over_traditional": 1.1374519390653124 + }, + { + "task": "content-regex", + "files": 100, + "history_old_over_current": 1.498453677691811, + "confirmation_old_over_current": 1.6049475208706145, + "latest_over_traditional": 0.6960802849377146, + "latest_cpu_over_traditional": 0.7949034250528297, + "confirmation_latest_over_traditional": 0.6974741181918752 + }, + { + "task": "content-regex", + "files": 10000, + "history_old_over_current": 1.2417231705502594, + "confirmation_old_over_current": 1.2323769989635132, + "latest_over_traditional": 0.630811622442185, + "latest_cpu_over_traditional": 0.6151759964092648, + "confirmation_latest_over_traditional": 0.6321080741326988 + }, + { + "task": "content-regex", + "files": 100000, + "history_old_over_current": 1.0907269351182531, + "confirmation_old_over_current": 1.1118600370396818, + "latest_over_traditional": 0.7259766358577342, + "latest_cpu_over_traditional": 0.6478586209191777, + "confirmation_latest_over_traditional": 0.7207039168080875 + }, + { + "task": "archive-tar", + "files": 100, + "history_old_over_current": 1.0064932237436375, + "confirmation_old_over_current": 0.9961973700487617, + "latest_over_traditional": 1.3102628176097213, + "latest_cpu_over_traditional": 1.6097611620413317, + "confirmation_latest_over_traditional": 1.2958620438806288 + }, + { + "task": "archive-tar", + "files": 1000, + "history_old_over_current": 1.3486287427494554, + "confirmation_old_over_current": 1.5112138888096927, + "latest_over_traditional": 1.043890375574132, + "latest_cpu_over_traditional": 1.2536957125269106, + "confirmation_latest_over_traditional": 1.0641148249612151 + }, + { + "task": "archive-tar", + "files": 10000, + "history_old_over_current": 1.6040516122338457, + "confirmation_old_over_current": 1.6270951842928545, + "latest_over_traditional": 0.8677818845838654, + "latest_cpu_over_traditional": 1.0316395332132986, + "confirmation_latest_over_traditional": 0.8595640695331399 + } + ], + "selected_source_steps": [ + { + "before_pr": 1033, + "after_pr": 1034, + "task": "files-exact", + "files": 100, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.9825843071625519 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "files-exact", + "files": 10000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 1.0114766237900956 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "files-exact", + "files": 100000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.9928888664964224 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "name-native", + "files": 100, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.9731997458558397 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "name-native", + "files": 10000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 1.2177951146531825 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "name-native", + "files": 100000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.9851816706928574 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "metadata-time", + "files": 100, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.992484698139729 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "metadata-time", + "files": 10000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.986124099112915 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "metadata-time", + "files": 100000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.9985796582677251 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "content-regex", + "files": 100, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 1.5566494130296342 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "content-regex", + "files": 10000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 1.1647711152959221 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "content-regex", + "files": 100000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.9989581152335578 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "archive-tar", + "files": 100, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 0.9918803380974661 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "archive-tar", + "files": 1000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 1.4781599751792802 + }, + { + "before_pr": 1033, + "after_pr": 1034, + "task": "archive-tar", + "files": 10000, + "before_binary_sha256": "e993e32ff19aba045d4cc34c89b60d5525538e3eed56a21f44583b902e2d4b08", + "after_binary_sha256": "72bb65654ff68ef82f2af5526eddc66e2356dda8a1ced18776587bcbfea450ac", + "before_over_after_adjusted_by_fixed_current": 1.0866220435050329 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "files-exact", + "files": 100, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.0094546488042846 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "files-exact", + "files": 10000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.0199056633627333 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "files-exact", + "files": 100000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 0.9966884385577325 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "name-native", + "files": 100, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.036978667553681 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "name-native", + "files": 10000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 2.3256468655352323 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "name-native", + "files": 100000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 2.2407600123362337 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "metadata-time", + "files": 100, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.0040145385903665 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "metadata-time", + "files": 10000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 0.997228994736047 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "metadata-time", + "files": 100000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.0010499270004465 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "content-regex", + "files": 100, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.0163278120843455 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "content-regex", + "files": 10000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.0018581246193417 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "content-regex", + "files": 100000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 0.9759747743414103 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "archive-tar", + "files": 100, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.004725710060068 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "archive-tar", + "files": 1000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 1.0122927651060343 + }, + { + "before_pr": 1090, + "after_pr": 1091, + "task": "archive-tar", + "files": 10000, + "before_binary_sha256": "7a5ecad4dc6c7b556bfe5714816ab2951e7d54b4ec0cf7dc184af919f1270482", + "after_binary_sha256": "cd3e3a978cb76b9710061726e85257ad70a83ea614b70f8e7c41961f9dcecded", + "before_over_after_adjusted_by_fixed_current": 0.9947153928078641 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "files-exact", + "files": 100, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9963783540185087 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "files-exact", + "files": 10000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 1.006495868629379 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "files-exact", + "files": 100000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9970619753534302 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "name-native", + "files": 100, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9955077071754045 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "name-native", + "files": 10000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9554680623025885 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "name-native", + "files": 100000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 1.0041848662755732 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "metadata-time", + "files": 100, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 1.0064745300166122 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "metadata-time", + "files": 10000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.987196485535755 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "metadata-time", + "files": 100000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9948277841128346 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "content-regex", + "files": 100, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9879395470721639 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "content-regex", + "files": 10000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9885775683113991 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "content-regex", + "files": 100000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 0.9908482166329988 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "archive-tar", + "files": 100, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 1.003341338543004 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "archive-tar", + "files": 1000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 1.0121727825352635 + }, + { + "before_pr": 1104, + "after_pr": 1105, + "task": "archive-tar", + "files": 10000, + "before_binary_sha256": "e913d4096deb6a52921716f847b5048c21ac1f9a13cb0fa0a2fbfc3d8ab8dbf1", + "after_binary_sha256": "731d04a57027197083508232323dcc80dc8f106948335a30fc8b190edb495e69", + "before_over_after_adjusted_by_fixed_current": 1.432431854239027 + } + ], + "small_regex_cells": [ + { + "population": "history", + "pr": "977", + "shape": "broad", + "cpus": "1", + "xff_seconds": "0.0016710347263142467", + "anchor_seconds": "0.001681273420607405", + "historical_over_current": "0.9939101551433203", + "paired_ratio_ci_low": "0.959941392479209", + "paired_ratio_ci_high": "1.0343231495565237" + }, + { + "population": "history", + "pr": "977", + "shape": "broad", + "cpus": "3", + "xff_seconds": "0.004980275157972106", + "anchor_seconds": "0.0018540473122681891", + "historical_over_current": "2.6861640072600834", + "paired_ratio_ci_low": "2.6161004983338763", + "paired_ratio_ci_high": "2.7272417166315153" + }, + { + "population": "history", + "pr": "977", + "shape": "deep", + "cpus": "1", + "xff_seconds": "0.0027394588604303344", + "anchor_seconds": "0.0027759504238409655", + "historical_over_current": "0.9868543893661691", + "paired_ratio_ci_low": "0.9795300335727859", + "paired_ratio_ci_high": "1.1753830292587168" + }, + { + "population": "history", + "pr": "977", + "shape": "deep", + "cpus": "3", + "xff_seconds": "0.006315978127531707", + "anchor_seconds": "0.0033006544524271575", + "historical_over_current": "1.9135532721055402", + "paired_ratio_ci_low": "1.809363917661038", + "paired_ratio_ci_high": "2.163759387863471" + }, + { + "population": "history", + "pr": "1033", + "shape": "broad", + "cpus": "1", + "xff_seconds": "0.0015752005856484175", + "anchor_seconds": "0.0015726935983236348", + "historical_over_current": "1.0015940723148202", + "paired_ratio_ci_low": "0.9646224984435313", + "paired_ratio_ci_high": "1.045668662613237" + }, + { + "population": "history", + "pr": "1033", + "shape": "broad", + "cpus": "3", + "xff_seconds": "0.004972890152462891", + "anchor_seconds": "0.0018120538775942155", + "historical_over_current": "2.7443390143924304", + "paired_ratio_ci_low": "2.643693751426407", + "paired_ratio_ci_high": "2.772737757813301" + }, + { + "population": "history", + "pr": "1033", + "shape": "deep", + "cpus": "1", + "xff_seconds": "0.0017297630131776845", + "anchor_seconds": "0.0016901541301714523", + "historical_over_current": "1.0234350715707887", + "paired_ratio_ci_low": "0.9712475461349225", + "paired_ratio_ci_high": "1.0517585664451794" + }, + { + "population": "history", + "pr": "1033", + "shape": "deep", + "cpus": "3", + "xff_seconds": "0.005292843129219753", + "anchor_seconds": "0.0021289417220811757", + "historical_over_current": "2.486138100598481", + "paired_ratio_ci_low": "2.026030176343772", + "paired_ratio_ci_high": "2.6907629008578184" + }, + { + "population": "history", + "pr": "1034", + "shape": "broad", + "cpus": "1", + "xff_seconds": "0.0018035041534208826", + "anchor_seconds": "0.0017929983025948917", + "historical_over_current": "1.005859375778988", + "paired_ratio_ci_low": "0.9884824347601571", + "paired_ratio_ci_high": "1.028089420673982" + }, + { + "population": "history", + "pr": "1034", + "shape": "broad", + "cpus": "3", + "xff_seconds": "0.0036680350146655527", + "anchor_seconds": "0.0030672683912728515", + "historical_over_current": "1.1958637284895033", + "paired_ratio_ci_low": "0.9265694994461793", + "paired_ratio_ci_high": "1.4068338797820439" + }, + { + "population": "history", + "pr": "1034", + "shape": "deep", + "cpus": "1", + "xff_seconds": "0.0017154451426384704", + "anchor_seconds": "0.001759351447357663", + "historical_over_current": "0.9750440397879943", + "paired_ratio_ci_low": "0.95264338873337", + "paired_ratio_ci_high": "0.9921720086490295" + }, + { + "population": "history", + "pr": "1034", + "shape": "deep", + "cpus": "3", + "xff_seconds": "0.008054083562456071", + "anchor_seconds": "0.007930626992934517", + "historical_over_current": "1.015567062936076", + "paired_ratio_ci_low": "0.8670341851111009", + "paired_ratio_ci_high": "1.1725030398957128" + }, + { + "population": "history", + "pr": "1130", + "shape": "broad", + "cpus": "1", + "xff_seconds": "0.0015169271334473575", + "anchor_seconds": "0.0015153431533170597", + "historical_over_current": "1.0010452946758828", + "paired_ratio_ci_low": "0.9643817952019261", + "paired_ratio_ci_high": "1.0337225276938102" + }, + { + "population": "history", + "pr": "1130", + "shape": "broad", + "cpus": "3", + "xff_seconds": "0.0017242921416514686", + "anchor_seconds": "0.0017369317190189446", + "historical_over_current": "0.992723043036709", + "paired_ratio_ci_low": "0.9560455859948186", + "paired_ratio_ci_high": "1.018312583924466" + }, + { + "population": "history", + "pr": "1130", + "shape": "deep", + "cpus": "1", + "xff_seconds": "0.0016098238328205688", + "anchor_seconds": "0.001642761702117111", + "historical_over_current": "0.9799496973577523", + "paired_ratio_ci_low": "0.9420220746973745", + "paired_ratio_ci_high": "1.0554051152394257" + }, + { + "population": "history", + "pr": "1130", + "shape": "deep", + "cpus": "3", + "xff_seconds": "0.001852560173054891", + "anchor_seconds": "0.001856804027089051", + "historical_over_current": "0.9977144308326318", + "paired_ratio_ci_low": "0.9849442857286673", + "paired_ratio_ci_high": "1.0263648122587694" + }, + { + "population": "confirmation", + "pr": "977", + "shape": "broad", + "cpus": "1", + "xff_seconds": "0.0015427176729731617", + "anchor_seconds": "0.0015659016290945666", + "historical_over_current": "0.9851945002861959", + "paired_ratio_ci_low": "0.9605089506749647", + "paired_ratio_ci_high": "1.010185204049759" + }, + { + "population": "confirmation", + "pr": "977", + "shape": "broad", + "cpus": "3", + "xff_seconds": "0.0049053284317432415", + "anchor_seconds": "0.0017810873243780364", + "historical_over_current": "2.754120117864633", + "paired_ratio_ci_low": "2.693844472298893", + "paired_ratio_ci_high": "2.7704238459584882" + }, + { + "population": "confirmation", + "pr": "977", + "shape": "deep", + "cpus": "1", + "xff_seconds": "0.0016358160535760579", + "anchor_seconds": "0.0016835721242906792", + "historical_over_current": "0.9716340808774427", + "paired_ratio_ci_low": "0.9501894296120165", + "paired_ratio_ci_high": "0.9878697250060161" + }, + { + "population": "confirmation", + "pr": "977", + "shape": "deep", + "cpus": "3", + "xff_seconds": "0.005176740903629079", + "anchor_seconds": "0.002056935530466338", + "historical_over_current": "2.5167249177009614", + "paired_ratio_ci_low": "2.412573306020054", + "paired_ratio_ci_high": "2.5285988148553025" + }, + { + "population": "confirmation", + "pr": "1130", + "shape": "broad", + "cpus": "1", + "xff_seconds": "0.0014728482457853499", + "anchor_seconds": "0.0014838081440843997", + "historical_over_current": "0.9926136688609344", + "paired_ratio_ci_low": "0.9674914380341627", + "paired_ratio_ci_high": "1.0138218443756903" + }, + { + "population": "confirmation", + "pr": "1130", + "shape": "broad", + "cpus": "3", + "xff_seconds": "0.0017203119184289659", + "anchor_seconds": "0.0017449967674024048", + "historical_over_current": "0.9858539285375384", + "paired_ratio_ci_low": "0.9689654128867984", + "paired_ratio_ci_high": "1.0077053999947865" + }, + { + "population": "confirmation", + "pr": "1130", + "shape": "deep", + "cpus": "1", + "xff_seconds": "0.0016057007513674243", + "anchor_seconds": "0.0016249004263608228", + "historical_over_current": "0.9881840913560478", + "paired_ratio_ci_low": "0.9679646766946779", + "paired_ratio_ci_high": "1.009781131468912" + }, + { + "population": "confirmation", + "pr": "1130", + "shape": "deep", + "cpus": "3", + "xff_seconds": "0.0018734393940706337", + "anchor_seconds": "0.001920311595313251", + "historical_over_current": "0.9755913564459984", + "paired_ratio_ci_low": "0.9511002344421833", + "paired_ratio_ci_high": "0.9928800128310572" + } + ], + "source_evidence_root": "/home/marcus/Documents/xff-chart-campaign-20261107", + "raw_csv_evidence": [ + "preview/cells.csv", + "preview/history-by-task.csv", + "preview/current-versus-reference.csv", + "preview/confirmation/cells.csv" + ] +} diff --git a/docs/benchmarks/extended-history-revisions-20261107.json b/docs/benchmarks/extended-history-revisions-20261107.json new file mode 100644 index 00000000000..bbfdaab8fa7 --- /dev/null +++ b/docs/benchmarks/extended-history-revisions-20261107.json @@ -0,0 +1,782 @@ +[ + { + "sha": "21c7f3656b005b23113d936c1cd2ca0fd2221ab2", + "date": "2026-10-06T02:23:48+01:00", + "subject": "Prepare peer and expected-hash field templates once (#977)", + "pr": 977 + }, + { + "sha": "c33efe99d0df0b4866a9f77fde71dde9959d3cdb", + "date": "2026-10-06T03:40:08+01:00", + "subject": "Adapt benchmark shard count to runner CPU agreement (#981)", + "pr": 981 + }, + { + "sha": "103fbf65b22979f75f5adbac67a53f15cf74d03e", + "date": "2026-10-06T21:09:52+01:00", + "subject": "Improve local benchmark backfill and upload workflow (#982)", + "pr": 982 + }, + { + "sha": "9210100af8007a2f17b22597a349714d9e6069e1", + "date": "2026-10-06T23:08:43+01:00", + "subject": "Add versioned prepared benchmark layouts (#985)", + "pr": 985 + }, + { + "sha": "61ab1ce41300aa785d6beafb46c29b29dc832b8d", + "date": "2026-10-07T22:29:50+01:00", + "subject": "Distinguish benchmark layout versions in explorer (#986)", + "pr": 986 + }, + { + "sha": "4bce0bb39186d1dfbe122038f17ef660447599c6", + "date": "2026-10-07T23:23:39+01:00", + "subject": "Clarify benchmark dataset selection and upload batches (#987)", + "pr": 987 + }, + { + "sha": "fa41587198981a5619e408c41be80cb22b8dd439", + "date": "2026-10-09T17:03:40+01:00", + "subject": "Refine benchmark viewer cards and threshold controls (#988)", + "pr": 988 + }, + { + "sha": "772994ab7905be77915978f06ea90ae5934aaeef", + "date": "2026-10-09T18:20:37+01:00", + "subject": "Call benchmark viewer measurement series Dataset (#989)", + "pr": 989 + }, + { + "sha": "4ea895f63106f05df7c90b629d20433ae1e03016", + "date": "2026-10-09T22:05:33+01:00", + "subject": "Verify benchmark build provenance and show binary evidence in the viewer (#990)", + "pr": 990 + }, + { + "sha": "dac3747d63cad713def0b949a934dfe36f82da63", + "date": "2026-10-10T11:32:31+01:00", + "subject": "Enable opt-in native Linux benchmark performance counters (#993)", + "pr": 993 + }, + { + "sha": "88d4facd15ebd00acf749222b3028de2e8916970", + "date": "2026-10-10T12:44:39+01:00", + "subject": "Correct native benchmark accounting and retain audit evidence (#994)", + "pr": 994 + }, + { + "sha": "bbc0bf9376c7fc41fe75094998c3c7e74bd02e94", + "date": "2026-10-10T13:42:01+01:00", + "subject": "Fix benchmark launcher staging and consolidate audit preparation (#999)", + "pr": 999 + }, + { + "sha": "b137c8a6800aa0c1d6f2d67342f291b25783747f", + "date": "2026-10-10T17:31:06+01:00", + "subject": "Publish executor dispatch evidence and simplify history chart folding (#1003)", + "pr": 1003 + }, + { + "sha": "d73eea93ac97f401fe12ba2ba139eb6b8601ec19", + "date": "2026-10-14T21:35:19+01:00", + "subject": "Bump rules_cc from 0.2.25 to 0.2.26 (#1004)", + "pr": 1004 + }, + { + "sha": "20095dd53c31e510aac2256fc93d34026e4f463c", + "date": "2026-10-14T21:58:37Z", + "subject": "Bump pcre2 from 10.48 to 10.49 (#1006)", + "pr": 1006 + }, + { + "sha": "33a01e13d7cd27ee7f866802fc2f74998fdcaabb", + "date": "2026-10-15T00:16:51+01:00", + "subject": "Bump rules_python from 2.3.4 to 2.4.2 (#1007)", + "pr": 1007 + }, + { + "sha": "bfe77198c06bc1e4a23e23ea292ab47cb4b6a0e4", + "date": "2026-10-15T00:28:32Z", + "subject": "Bump zstd from 1.5.7.bcr.2 to 1.5.7.bcr.3 (#1005)", + "pr": 1005 + }, + { + "sha": "1f85d90e3441737304d9f3647523cfc408ca54a9", + "date": "2026-10-15T03:34:18+01:00", + "subject": "Handle contract drift in adaptive benchmark sampling (#1009)", + "pr": 1009 + }, + { + "sha": "a5f9c9ec07419101cfe73ec4b42c3c29c529edad", + "date": "2026-10-17T10:57:28+01:00", + "subject": "Fix clang-tidy source queries and batch preparation builds (#1010)", + "pr": 1010 + }, + { + "sha": "a21ada79bbe9cad232a174cfdb4e8923ed891f2a", + "date": "2026-10-17T12:38:48+01:00", + "subject": "Bump toolchains_llvm from 1.11.1 to 1.11.3 (#1008)", + "pr": 1008 + }, + { + "sha": "ae62c828a3f3502a9bcf4805188913a1aaaf264c", + "date": "2026-10-18T23:31:25+01:00", + "subject": "Resolve golden test inputs through runfiles lookup (#1012)", + "pr": 1012 + }, + { + "sha": "801087f3e9a8bf192928896c7f24c369003d1e7b", + "date": "2026-10-23T02:56:26+01:00", + "subject": "Follow stable LLVM 23 releases from the pinned catalogue (#1011)", + "pr": 1011 + }, + { + "sha": "3dbc47cc2a1d84c0e6b60f0a497c1d3ce160351f", + "date": "2026-10-23T04:10:00+01:00", + "subject": "Bump setup-bazel to 0.19.1 and align pin checks (#1013)", + "pr": 1013 + }, + { + "sha": "8e95f5546187b2a6f4ec165af9cf794af18ac4a1", + "date": "2026-10-27T01:23:53Z", + "subject": "Add reverse diffs and configurable patch paths (#1019)", + "pr": 1019 + }, + { + "sha": "1642f49d7b400596af3ed627f5b9f42cc24e4237", + "date": "2026-10-27T02:19:56Z", + "subject": "Allow stamped release versions in the rg alias test (#1021)", + "pr": 1021 + }, + { + "sha": "eaa034527a286ed87f1f74b8e88ba5b7007fb31a", + "date": "2026-10-27T06:43:43Z", + "subject": "Open CHANGELOG section for 0.10.0 (#1020)", + "pr": 1020 + }, + { + "sha": "02292572cac61101036c032ece8e11675d580d7e", + "date": "2026-10-28T01:21:30Z", + "subject": "Add selectable ignore policies to tree comparison (#1022)", + "pr": 1022 + }, + { + "sha": "b52571f81b8ecec116a4249f51b7d5e72175248c", + "date": "2026-10-28T23:28:49Z", + "subject": "Unify generated help references and remove duplicate navigation (#1023)", + "pr": 1023 + }, + { + "sha": "f0407980edd2bc2497dc0f406b2fed1977caaaea", + "date": "2026-10-29T02:06:19Z", + "subject": "Apply explicit ignore files to both comparison roots (#1024)", + "pr": 1024 + }, + { + "sha": "4c87962565391caf32b669c6a8a55d7495999921", + "date": "2026-10-29T02:52:41Z", + "subject": "Produce complete Git patches for tree comparisons (#1025)", + "pr": 1025 + }, + { + "sha": "b7fd2c2d0c5d50d8e5895f36fe39f802ac2dcb76", + "date": "2026-10-29T03:30:29Z", + "subject": "Place comparison features under the 0.10.0 release (#1026)", + "pr": 1026 + }, + { + "sha": "d406f4132d067d4e87a8df1426753a7d0203abd6", + "date": "2026-10-29T04:10:06Z", + "subject": "Honor no-ignore for ordinary explicit ignore files (#1027)", + "pr": 1027 + }, + { + "sha": "d47b00bfeeb3b98606d806c4b21664870d3ddfaa", + "date": "2026-10-29T04:56:29Z", + "subject": "Diagnose ineffective file-diff normalization before actions (#1028)", + "pr": 1028 + }, + { + "sha": "3292b6f308ab92f61d8575c95ee2cef2c41e4205", + "date": "2026-10-29T05:34:26Z", + "subject": "Round-trip staged release comparison patches through Git (#1029)", + "pr": 1029 + }, + { + "sha": "96174bbdd64ab2325224f47bab43888fa224595b", + "date": "2026-10-29T21:21:24Z", + "subject": "Open CHANGELOG section for 0.11.0 (#1030)", + "pr": 1030 + }, + { + "sha": "bfae14510a3e302f524b96719a695ca4bb07ffbd", + "date": "2026-10-30T23:45:26Z", + "subject": "Recover the original 0.9.0 release without moving its tag (#1031)", + "pr": 1031 + }, + { + "sha": "3803544ef4a24e0a72e54a317ee5091638bc70ae", + "date": "2026-10-31T15:27:47Z", + "subject": "Upgrade five dependencies and fix Bazel integration (#1032)", + "pr": 1032 + }, + { + "sha": "a721b98a306dd9021d31bbc485ae4c7c82ceba00", + "date": "2026-10-31T19:59:00Z", + "subject": "Upgrade bashtest to 0.7.1 and remove launcher workaround (#1033)", + "pr": 1033 + }, + { + "sha": "974d137026818bba1c1deaf6cfc4fffe676b314e", + "date": "2026-10-31T22:11:51Z", + "subject": "Avoid Abseil hardware-clock calibration during worker startup (#1034)", + "pr": 1034 + }, + { + "sha": "66302319f016c5f459b0260a2e727bd32073ed24", + "date": "2026-11-01T10:43:47Z", + "subject": "Clarify benchmark uploader revision overlap (#1036)", + "pr": 1036 + }, + { + "sha": "b68a9c3a58abd219a5043d5737e23f6ebe5ee26c", + "date": "2026-11-01T11:35:52Z", + "subject": "Make local benchmark uploads and publication more reliable (#1038)", + "pr": 1038 + }, + { + "sha": "8ff28cde9c67bd498f9016935da01506ffb5845c", + "date": "2026-11-01T12:37:28Z", + "subject": "Isolate executor diagnostics and query download support (#1035)", + "pr": 1035 + }, + { + "sha": "473f73452a6b47d7a3b522f2cc6128c4fafa86d8", + "date": "2026-11-01T13:41:30Z", + "subject": "Avoid temporary key construction and retain executor audit evidence (#1037)", + "pr": 1037 + }, + { + "sha": "7b72a5f0a52e838dfe0b199ea0386c8e6b3dcd39", + "date": "2026-11-01T18:38:17Z", + "subject": "Bound sibling reads on the existing directory pool (#1039)", + "pr": 1039 + }, + { + "sha": "16e70cb97de93c7ab4ae8c9e990e1842d50cc528", + "date": "2026-11-01T21:40:15Z", + "subject": "Use fixed 1 MiB blocks for retained collection text (#1040)", + "pr": 1040 + }, + { + "sha": "cf23601ab3533c2acb938acda1439dcd69091f61", + "date": "2026-11-01T23:34:14Z", + "subject": "Share collection name and root storage with owned paths (#1041)", + "pr": 1041 + }, + { + "sha": "2b21790502fd6bf9b6e1afb53cc1444cf140f296", + "date": "2026-11-02T00:25:41Z", + "subject": "Prepare simple native globs and avoid pattern copies (#1042)", + "pr": 1042 + }, + { + "sha": "9e4338a6ea3b47431e612a1fa24b818b3269193d", + "date": "2026-11-02T01:26:44Z", + "subject": "Reuse fuzzy score rows and cache normalization ceilings (#1043)", + "pr": 1043 + }, + { + "sha": "d546fcb3d864ed18776f642c1aa0fe904e9f8bfa", + "date": "2026-11-02T02:30:36Z", + "subject": "Render lexical filename fields from borrowed path slices (#1044)", + "pr": 1044 + }, + { + "sha": "35479b4fe8dec5a7a9400bca69f69516df5f56f0", + "date": "2026-11-02T03:31:09Z", + "subject": "Record rejected field lookup allocation experiments (#1045)", + "pr": 1045 + }, + { + "sha": "7c0f507f7c815146a9b746e40269377dbc768b37", + "date": "2026-11-02T04:25:35Z", + "subject": "Avoid redundant zeroing in native bounded range reads (#1046)", + "pr": 1046 + }, + { + "sha": "c14d39cf281c084f8833bc877fca6999e2f9f810", + "date": "2026-11-02T05:40:01Z", + "subject": "Reuse budgeted native comparison cursor buffers (#1047)", + "pr": 1047 + }, + { + "sha": "7cf2a52441d626888b5840d09a4646d6dedca6b9", + "date": "2026-11-02T06:41:21Z", + "subject": "Reuse typed directory task slots with atomic completion (#1048)", + "pr": 1048 + }, + { + "sha": "901c8fea916124f4d0e195c5385f2a977b44093d", + "date": "2026-11-02T08:15:37Z", + "subject": "Pack owned matcher and deferred entry text (#1049)", + "pr": 1049 + }, + { + "sha": "2d615ea1e447e55c266a47799ad6cd64bd4e246d", + "date": "2026-11-02T10:02:48Z", + "subject": "Reuse bounded matcher output capacities across batches (#1050)", + "pr": 1050 + }, + { + "sha": "d903ea98a98f4220d9372ab0404ee974eccb8690", + "date": "2026-11-02T11:07:53Z", + "subject": "Limit warmed matcher participation to available work chunks (#1051)", + "pr": 1051 + }, + { + "sha": "76cc22da343841f9786bc9f78e21e839084a780f", + "date": "2026-11-02T12:17:40Z", + "subject": "Record direct evaluator worker qualification and rejection (#1052)", + "pr": 1052 + }, + { + "sha": "dc4e70237eff58916c4eb6990047904536397264", + "date": "2026-11-02T13:14:55Z", + "subject": "Reuse requested content values across worker stages (#1053)", + "pr": 1053 + }, + { + "sha": "96fa46b86017dc2a79bc97624af9ac98401190ed", + "date": "2026-11-02T13:53:40Z", + "subject": "Reuse immutable default catalogs across library runs (#1054)", + "pr": 1054 + }, + { + "sha": "00d4f84df01e00f1ce2d7c83576ac38b2eb2fb7b", + "date": "2026-11-02T14:57:51Z", + "subject": "Prepare immutable file-diff configuration once per style (#1055)", + "pr": 1055 + }, + { + "sha": "fc2cd316e81d7319aa44912e786e7aad4492cd0a", + "date": "2026-11-02T20:24:00Z", + "subject": "Prepare compact hash-primary operands once per expression (#1056)", + "pr": 1056 + }, + { + "sha": "6bebe940ba36328a399461a19434bf627118bf75", + "date": "2026-11-02T21:02:54Z", + "subject": "Aggregate ordinary comparison side totals directly (#1057)", + "pr": 1057 + }, + { + "sha": "c004bcc65f16df2a264fd5451e4bc7262fecd137", + "date": "2026-11-02T22:25:59Z", + "subject": "Free hosted Linux build space before LLVM extraction (#1058)", + "pr": 1058 + }, + { + "sha": "4b823112efb377658029a2a3d5c4c51594f03e25", + "date": "2026-11-03T01:21:35Z", + "subject": "Aggregate five Bazel dependency bumps (#1065)", + "pr": 1065 + }, + { + "sha": "22702c34a0bcb261238af40f82818369fa46a4ab", + "date": "2026-11-03T01:24:02Z", + "subject": "perf: reduce byte-word shingle allocation and copying (#1059)", + "pr": 1059 + }, + { + "sha": "09e6bbfff3275ed36eba7b98052cf5d0877d94f7", + "date": "2026-11-03T02:42:57Z", + "subject": "Reuse archive input buffers without per-chunk allocations (#1066)", + "pr": 1066 + }, + { + "sha": "fb726c946063d567320d76f2f3d706f0a0997e57", + "date": "2026-11-03T03:38:30Z", + "subject": "Borrow cached digests and streamline output records (#1067)", + "pr": 1067 + }, + { + "sha": "58ba30eeb90499f50e98da480b8d965047352b1f", + "date": "2026-11-03T04:47:07Z", + "subject": "Reuse caller-owned buffers for memory and archive member streams (#1068)", + "pr": 1068 + }, + { + "sha": "6d6a2c9abf972ffffd064939381a1df2f40c2776", + "date": "2026-11-03T05:44:49Z", + "subject": "Fill source results directly and reuse owned decoder blocks (#1069)", + "pr": 1069 + }, + { + "sha": "44e7e30102eb6c6ae122135189b6c62340c35bdb", + "date": "2026-11-03T07:51:58Z", + "subject": "Bind hash field qualifiers once without growing template segments (#1070)", + "pr": 1070 + }, + { + "sha": "79f8b371480551c70654e1e83712ebdb6539ca0a", + "date": "2026-11-03T09:06:21Z", + "subject": "Skip discarded archive payloads through bounded owned cursors (#1071)", + "pr": 1071 + }, + { + "sha": "0fe856d76f6583c3a0023cf6f8f5654bf949bd40", + "date": "2026-11-03T10:26:07Z", + "subject": "Reuse coordinator-owned raw listing records (#1072)", + "pr": 1072 + }, + { + "sha": "6db2de9e49f19107f49e257486b50694a764cf23", + "date": "2026-11-03T11:32:14Z", + "subject": "Borrow the similarity reference sniff prefix (#1073)", + "pr": 1073 + }, + { + "sha": "7173ffcbc66063560d31e04fdd58fa4a1c6ebe8c", + "date": "2026-11-03T13:01:55Z", + "subject": "Free unused hosted SDKs before extracting LLVM toolchains (#1074)", + "pr": 1074 + }, + { + "sha": "62400cd3b12ec42c2b1aa7dec049c2510cbf456a", + "date": "2026-11-03T15:49:15Z", + "subject": "Reuse freshly verified literal similarity references (#1075)", + "pr": 1075 + }, + { + "sha": "653f5ed25b68e84e0b292afa9671289eade3b534", + "date": "2026-11-03T17:35:11Z", + "subject": "Move already-owned single-word similarity keys (#1076)", + "pr": 1076 + }, + { + "sha": "35b810bb806aa169c075c01a449a408cd3758248", + "date": "2026-11-03T18:31:01Z", + "subject": "Probe the smaller similarity shingle set (#1077)", + "pr": 1077 + }, + { + "sha": "76054b3a9c60baa72afd0452bbc3ac6bc2f79efd", + "date": "2026-11-03T20:22:28Z", + "subject": "Benchmark ZIP readers and retain rejected native-seek evaluation (#1078)", + "pr": 1078 + }, + { + "sha": "01ace14aa38a87db7d2f1441043cd61cf0b3de49", + "date": "2026-11-04T00:08:29Z", + "subject": "Reuse bounded encoded path-record storage (#1079)", + "pr": 1079 + }, + { + "sha": "0d64bb3974f4e70bc5dfc36ea8647e7e7db3cbf5", + "date": "2026-11-04T01:50:02Z", + "subject": "Reduce hosted MSan debug payload to avoid cold-build disk exhaustion (#1081)", + "pr": 1081 + }, + { + "sha": "669f68a3e26303c06325c6beaee44019481bcaf9", + "date": "2026-11-04T04:13:14Z", + "subject": "Decide similarity thresholds with exact batched bounds (#1080)", + "pr": 1080 + }, + { + "sha": "6e6b25ffc8696d6d28867a1ee6ea2e9beb00a77d", + "date": "2026-11-04T06:06:23Z", + "subject": "Reuse coordinator-owned column cells and bounded CSV/TSV row storage (#1082)", + "pr": 1082 + }, + { + "sha": "f9a73afa1497589b49f33c99c49248adf3a7b38e", + "date": "2026-11-04T07:19:35Z", + "subject": "Preserve short-word batches and reuse long-word similarity scratch (#1083)", + "pr": 1083 + }, + { + "sha": "f06cea15f5b1b0b04be246501c894b79782eb0fd", + "date": "2026-11-04T08:19:37Z", + "subject": "Reuse field contexts and transfer owned scalar output (#1084)", + "pr": 1084 + }, + { + "sha": "790dd72d400f7ac3e8656ea48c7ba718b41badd2", + "date": "2026-11-04T09:42:31Z", + "subject": "Construct only the selected comparison-summary output (#1085)", + "pr": 1085 + }, + { + "sha": "ba9b2baaf8d7ed7a7ffdeac7a16bd63f43255071", + "date": "2026-11-04T10:43:52Z", + "subject": "Use fixed-size numeric summary cells (#1086)", + "pr": 1086 + }, + { + "sha": "f7bdc5d248e76a54278aef5030c0a3468505bd2f", + "date": "2026-11-04T12:25:05Z", + "subject": "Encode summary cells without intermediate row vectors (#1087)", + "pr": 1087 + }, + { + "sha": "9bd70fc9b4607cd8a586615c630706f85416e62c", + "date": "2026-11-04T14:51:03Z", + "subject": "Retain compact comparison entries and path storage (#1088)", + "pr": 1088 + }, + { + "sha": "bec36225c686b58914e8ab9792e822d56fe1ef07", + "date": "2026-11-04T16:58:29Z", + "subject": "Append borrowed comparison categories in merge order (#1089)", + "pr": 1089 + }, + { + "sha": "798c2c0a3b4f9c1acfa050f2eac1b8902ba89ae8", + "date": "2026-11-04T19:17:45Z", + "subject": "Reuse native directory paths across leaf visits (#1090)", + "pr": 1090 + }, + { + "sha": "e66bdbe1097f4a051580dcbb68d17e745ec5e9ba", + "date": "2026-11-04T20:34:21Z", + "subject": "Avoid leaf metadata reads for uniform case policies (#1091)", + "pr": 1091 + }, + { + "sha": "a89459ed819af4fa6841a9ab7eca4e554949fd72", + "date": "2026-11-04T21:53:43Z", + "subject": "Accumulate native directory entries in stable segments (#1092)", + "pr": 1092 + }, + { + "sha": "a7a6125a9358f1020fc914d6c91bbf8c6e66392f", + "date": "2026-11-04T23:39:42Z", + "subject": "Keep benchmark task positions stable across merged history (#1093)", + "pr": 1093 + }, + { + "sha": "bb0185a0379075480eb8b1499f5bc5ff8cfafaa8", + "date": "2026-11-05T01:46:19Z", + "subject": "Keep traversal records compact with listing-owned metadata (#1094)", + "pr": 1094 + }, + { + "sha": "6792b5030de70a737dec2878673aebaa6ddc57af", + "date": "2026-11-05T03:32:21Z", + "subject": "Reuse native stat paths for eager directory listings (#1095)", + "pr": 1095 + }, + { + "sha": "39282994e036bb4dc43c2ca9ffdb2a2f498bb99d", + "date": "2026-11-05T04:48:08Z", + "subject": "Use scoped terminated storage for native stat paths (#1096)", + "pr": 1096 + }, + { + "sha": "910e2a7bbae50a3562135784d56e2ba903e89e7c", + "date": "2026-11-05T05:59:37Z", + "subject": "Record native-case experiment decisions and device-cache regressions (#1097)", + "pr": 1097 + }, + { + "sha": "7c8cd64e02a84ce13f5a7d3b3dd37290307a40a9", + "date": "2026-11-05T07:22:18Z", + "subject": "Reuse prepared folded ASCII glob shapes with native fallbacks (#1098)", + "pr": 1098 + }, + { + "sha": "76185cb37fa2d4f6cb36876efde58b0ede0e753a", + "date": "2026-11-05T09:06:33Z", + "subject": "Retain host-specific MSan caches under their sanitizer allowance (#1099)", + "pr": 1099 + }, + { + "sha": "57e9287e675f180ef6a7b0cc5d4e883605b1bfdf", + "date": "2026-11-05T11:00:54Z", + "subject": "Reuse optional bulk directory metadata with ordinary stat fallbacks (#1100)", + "pr": 1100 + }, + { + "sha": "318edb2f60ce1a9a526fc94a15ea7cdad4c4d181", + "date": "2026-11-05T14:14:49Z", + "subject": "Check XFF-owned headers through Bazel clang-tidy aliases (#1101)", + "pr": 1101 + }, + { + "sha": "55ea67e3f06e5055b43d8cb780661901731592f2", + "date": "2026-11-05T17:08:19Z", + "subject": "Skip unused ordinary scopes after comparison-only summaries (#1102)", + "pr": 1102 + }, + { + "sha": "f3ec0faf7a1bb16ddb0b3b8bcee2c3e5bd970df2", + "date": "2026-11-05T18:53:16Z", + "subject": "Record comparison-storage experiments without adopting regressions (#1103)", + "pr": 1103 + }, + { + "sha": "455dcd8eb5dd98b09f3117f5316136b6d43cfd8e", + "date": "2026-11-05T20:46:57Z", + "subject": "Reuse archive session input for format detection (#1104)", + "pr": 1104 + }, + { + "sha": "245e74ff6cbe6c0f84a074be669c60ac7cbc5e8f", + "date": "2026-11-05T22:29:23Z", + "subject": "Bound archive directory listings to their ordered subtree (#1105)", + "pr": 1105 + }, + { + "sha": "b60cf7a5a92609f9fadddd4759d3c55e755a69b6", + "date": "2026-11-06T00:26:31Z", + "subject": "Allow OS-version fallback after exhausting exact benchmark quorums (#1117)", + "pr": 1117 + }, + { + "sha": "e7e42d01e0678590fc06bd90b9143682a84aef7d", + "date": "2026-11-06T01:50:29Z", + "subject": "Resolve Bazel virtual include aliases for local clang-tidy scope (#1106)", + "pr": 1106 + }, + { + "sha": "ccb1f0a202ed59b30246c14e424a400e47acc447", + "date": "2026-11-06T03:31:50Z", + "subject": "Bound initial storage for archive directory listings (#1107)", + "pr": 1107 + }, + { + "sha": "adae6c9cd98bdd4b15f7b2867d08b1bfe12e1fad", + "date": "2026-11-06T04:40:27Z", + "subject": "Reuse indexed metadata during archive directory walks (#1108)", + "pr": 1108 + }, + { + "sha": "a1ff80a81c1ff2c4fd93898aeaf07dc2fc5764ff", + "date": "2026-11-06T05:46:37Z", + "subject": "Reuse complete Darwin bulk observations for non-followed symlinks (#1109)", + "pr": 1109 + }, + { + "sha": "e9bebfa5bfd85137de756047795887d45248ec18", + "date": "2026-11-06T06:49:18Z", + "subject": "Record rejected native metadata and queue cleanup experiments (#1110)", + "pr": 1110 + }, + { + "sha": "5cade08b6701417b07343b12ac86331ed0c3b941", + "date": "2026-11-06T07:59:12Z", + "subject": "Fix benchmark preview readiness for the combined aggregate (#1111)", + "pr": 1111 + }, + { + "sha": "852539d084ca1c4bb1756b0f83eb4b50b2b19b85", + "date": "2026-11-06T09:03:22Z", + "subject": "Defer coverage publication when its source is retried (#1112)", + "pr": 1112 + }, + { + "sha": "5729026a8482a2bc331058ee658017f9aba74298", + "date": "2026-11-06T10:09:24Z", + "subject": "Avoid unnecessary symlink target reads in formatted listings (#1113)", + "pr": 1113 + }, + { + "sha": "713abe5fa302c9ff78e7df769304f90379566c83", + "date": "2026-11-06T11:21:49Z", + "subject": "Record the published site storage review (#1114)", + "pr": 1114 + }, + { + "sha": "ab909839da7d1ae34ea63eab75ec83dc62fd33fb", + "date": "2026-11-06T12:35:53Z", + "subject": "Retain measured PGO and short-readlink performance decisions (#1115)", + "pr": 1115 + }, + { + "sha": "f4cee33eeb6b6cf00c1b39003b11fafbb262f79b", + "date": "2026-11-06T13:29:25Z", + "subject": "Skip empty CCTZ formatter fragments before libc (#1116)", + "pr": 1116 + }, + { + "sha": "c7bb70cc6f3e6441ff25c999667d76f48ffe9acb", + "date": "2026-11-06T14:32:34Z", + "subject": "Avoid temporary archive member keys (#1118)", + "pr": 1118 + }, + { + "sha": "2487927cc6b1de326ea3c6c058dc493214354bec", + "date": "2026-11-06T16:42:21Z", + "subject": "Reserve archive listings from child counts (#1120)", + "pr": 1120 + }, + { + "sha": "d9bf84b04784daf1d457a213f2dba277ba32ed2e", + "date": "2026-11-06T17:51:54Z", + "subject": "Avoid redundant archive directory separator scans (#1121)", + "pr": 1121 + }, + { + "sha": "0e95e191ba7d7ee3769217e7fbf82a825ff9b90d", + "date": "2026-11-06T19:06:09Z", + "subject": "Avoid copying owned archive bytes before parsing (#1122)", + "pr": 1122 + }, + { + "sha": "83657b9dfe35adda2a4cede5a1ae71db2f2b870d", + "date": "2026-11-06T20:08:59Z", + "subject": "Append structured field values without intermediate strings (#1123)", + "pr": 1123 + }, + { + "sha": "de2fa3557d69e9c3eb1c52bb2b0300566f960fea", + "date": "2026-11-06T22:11:55Z", + "subject": "Record completed-frontier comparison rejection (#1124)", + "pr": 1124 + }, + { + "sha": "c95140674254c371844f1fab27a64951a80dac55", + "date": "2026-11-06T23:53:55Z", + "subject": "Reserve LTO links for production CLIs and share Linux fat objects (#1119)", + "pr": 1119 + }, + { + "sha": "9bf1aad510d843d1d6338fbdf23107a30d339730", + "date": "2026-11-07T02:38:27Z", + "subject": "Record shared-worker qualification and retain specialized pools (#1125)", + "pr": 1125 + }, + { + "sha": "d8cf61cccd4b0efed5058bf6fa45228e47162b48", + "date": "2026-11-07T04:10:09Z", + "subject": "Record archive insertion qualification and reconcile tracking (#1126)", + "pr": 1126 + }, + { + "sha": "1786340680499f50b08dee5b1ceffbc20fd7b533", + "date": "2026-11-07T07:02:39Z", + "subject": "Reuse validated rg output transactions in matcher results (#1127)", + "pr": 1127 + }, + { + "sha": "1278c8943a6abd236a2f20e3937cc8e23a0f95a7", + "date": "2026-11-07T08:14:55Z", + "subject": "Decode embedded language JSON into final owned storage (#1128)", + "pr": 1128 + }, + { + "sha": "77aa9ef9bc9475adcbdd37cf3004143a96f03060", + "date": "2026-11-07T09:22:56Z", + "subject": "Record rejected hinted archive ancestor insertion screen (#1129)", + "pr": 1129 + }, + { + "sha": "ae8c5af3eb11dc8571f11db9b307b0db948f78c6", + "date": "2026-11-07T11:11:19Z", + "subject": "Stop main benchmarks once three of four candidates agree (#1130)", + "pr": 1130 + } +] diff --git a/docs/benchmarks/extended-history-viewer-check-20261107.json b/docs/benchmarks/extended-history-viewer-check-20261107.json new file mode 100644 index 00000000000..297ec5dc684 --- /dev/null +++ b/docs/benchmarks/extended-history-viewer-check-20261107.json @@ -0,0 +1,34 @@ +{ + "purpose": "synthetic renderer validation; not measurements", + "results": [ + { + "dataset": "Drogon / extended-production-v1 / Fixed XFF at PR #2", + "version": "0", + "measuredPoints": 60, + "missingPoints": 20, + "height": -100 + }, + { + "dataset": "Drogon / extended-production-v1 / Fixed XFF at PR #2", + "version": "1", + "measuredPoints": 60, + "missingPoints": 20, + "height": 0 + }, + { + "dataset": "Drogon / extended-production-v1 / Traditional tools", + "version": "0", + "measuredPoints": 60, + "missingPoints": 20, + "height": 50 + }, + { + "dataset": "Drogon / extended-production-v1 / Traditional tools", + "version": "1", + "measuredPoints": 60, + "missingPoints": 20, + "height": 75 + } + ], + "errors": [] +} diff --git a/docs/benchmarks/find-listing-optimization-20261107.json b/docs/benchmarks/find-listing-optimization-20261107.json new file mode 100644 index 00000000000..3d7258ecae0 --- /dev/null +++ b/docs/benchmarks/find-listing-optimization-20261107.json @@ -0,0 +1,5608 @@ +{ + "baseline": "90abd2b3ef63b35833e8f9d96745475c6b9f182a", + "candidate": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "stages": { + "archive-gate": { + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 60, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 30, + "control_p95_factor": 1.0173358757005602, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "c293d9770a72d631880e7537e29e8de609267a58892f330d9450066de4ec8d7e" + }, + "builds": [ + { + "source": { + "revision": "c97326cdec67667233e671cdadbb9ea19d333154", + "tree": "880d7109ba13c527d4b652e4816efd932b777969", + "clean": true + }, + "sha256": "7bf484e503e40886750188279c8d8b9130a1d0aa81a06cc08e102b9a598ec132", + "bytes": 18460464, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 18.718322283006273, + "completed_at": "2026-11-07T18:31:05.710190+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "90abd2b3ef63b35833e8f9d96745475c6b9f182a", + "tree": "3033d042fc343d55c7e62b322ea394f645b38559", + "clean": true + }, + "sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "bytes": 18457800, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 20.564833533018827, + "completed_at": "2026-11-07T15:48:41.518725+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "archive-gate", + "contract_sha256": "c293d9770a72d631880e7537e29e8de609267a58892f330d9450066de4ec8d7e", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 60, + "validated_invocations": 5040, + "numeric_fields": 300, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9564506599785295, + "candidate_over_reference": 1.4475976392955292, + "paired_ratio_ci": [0.9308963626523246, 0.979535882526343], + "candidate_seconds": 0.0013870759978003445, + "baseline_seconds": 0.001450232673613798, + "reference_seconds": 0.0009581916688364886 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9720969472810577, + "candidate_over_reference": 1.3061998198473788, + "paired_ratio_ci": [0.9563573688805616, 1.0082823151506752], + "candidate_seconds": 0.003870863134839705, + "baseline_seconds": 0.003981972318364396, + "reference_seconds": 0.00296345404127524 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9944222953539295, + "candidate_over_reference": 1.0960528343811524, + "paired_ratio_ci": [0.9915619217639648, 1.0010270677202375], + "candidate_seconds": 0.04313072315528102, + "baseline_seconds": 0.04337264294736087, + "reference_seconds": 0.039350952620485 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9697570627246743, + "candidate_over_reference": 1.405128059285615, + "paired_ratio_ci": [0.9525039435452187, 0.9895733713430094], + "candidate_seconds": 0.0014853451367733733, + "baseline_seconds": 0.0015316672534460114, + "reference_seconds": 0.0010570888019477327 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9869085578399542, + "candidate_over_reference": 1.2914988719922451, + "paired_ratio_ci": [0.9705996690163938, 1.0636334424461718], + "candidate_seconds": 0.006230432329522003, + "baseline_seconds": 0.006313079646566794, + "reference_seconds": 0.004824187201891272 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9978427093690609, + "candidate_over_reference": 1.1950395300087842, + "paired_ratio_ci": [0.9939276201754964, 1.0138780089393507], + "candidate_seconds": 0.05903094891081786, + "baseline_seconds": 0.059158571142082415, + "reference_seconds": 0.049396649590649065 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.948336389045526, + "candidate_over_reference": 1.4105649590916358, + "paired_ratio_ci": [0.8673563271423425, 0.9628029368399903], + "candidate_seconds": 0.0013636591888609387, + "baseline_seconds": 0.001437948817121131, + "reference_seconds": 0.0009667468201812534 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9858459840965057, + "candidate_over_reference": 1.2363695030241024, + "paired_ratio_ci": [0.9635540010097692, 1.0178677735730184], + "candidate_seconds": 0.004111019090660626, + "baseline_seconds": 0.0041700419304626325, + "reference_seconds": 0.00332507319260566 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9932517896810984, + "candidate_over_reference": 1.053231243966827, + "paired_ratio_ci": [0.9922015374378514, 1.0003188220094554], + "candidate_seconds": 0.04614337744368684, + "baseline_seconds": 0.046456878228733935, + "reference_seconds": 0.043811250101065354 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9651636561236406, + "candidate_over_reference": 1.385874800740761, + "paired_ratio_ci": [0.9479415084444648, 0.988154273570125], + "candidate_seconds": 0.001464318727985734, + "baseline_seconds": 0.0015171714337720047, + "reference_seconds": 0.001056602463081834 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9914414998774229, + "candidate_over_reference": 1.2017870245101692, + "paired_ratio_ci": [0.9790895766026101, 1.005139375932347], + "candidate_seconds": 0.005451280756720475, + "baseline_seconds": 0.005498338285611854, + "reference_seconds": 0.004535979042494935 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9968323152246604, + "candidate_over_reference": 1.0958411758637066, + "paired_ratio_ci": [0.9928654291293386, 1.003152960937573], + "candidate_seconds": 0.05457461850407223, + "baseline_seconds": 0.05474804304651029, + "reference_seconds": 0.04980157682162133 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9580766767872689, + "candidate_over_reference": 1.3846060648765004, + "paired_ratio_ci": [0.9099563015999332, 0.9649222190870447], + "candidate_seconds": 0.0014122108141669915, + "baseline_seconds": 0.0014740060460531996, + "reference_seconds": 0.0010199368975701787 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9946586545103228, + "candidate_over_reference": 1.1666779017359215, + "paired_ratio_ci": [0.9669023793700804, 1.01093412652428], + "candidate_seconds": 0.009269181655586831, + "baseline_seconds": 0.009318957426807, + "reference_seconds": 0.007944936337437303 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0027225710626018, + "candidate_over_reference": 1.070781297407446, + "paired_ratio_ci": [0.9997636745966381, 1.0068875205382208], + "candidate_seconds": 0.11593056105942066, + "baseline_seconds": 0.1156157888582952, + "reference_seconds": 0.10826726367009715 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9682158545729925, + "candidate_over_reference": 1.404366280797436, + "paired_ratio_ci": [0.9489407789828969, 0.9843957539515128], + "candidate_seconds": 0.0015659580073718513, + "baseline_seconds": 0.0016173645576816938, + "reference_seconds": 0.0011150638040687358 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9943708646165792, + "candidate_over_reference": 1.3183641683418872, + "paired_ratio_ci": [0.959114918185648, 1.0093229030935573], + "candidate_seconds": 0.012523743573443167, + "baseline_seconds": 0.012594640509979356, + "reference_seconds": 0.009499456883142037 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9975664634305181, + "candidate_over_reference": 1.2575281181958724, + "paired_ratio_ci": [0.9923249438029718, 1.0012998841997838], + "candidate_seconds": 0.133394931276728, + "baseline_seconds": 0.13372034462545776, + "reference_seconds": 0.10607709628640719 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9651292359635875, + "candidate_over_reference": 0.8559363750532576, + "paired_ratio_ci": [0.9482946216805443, 0.9900169624237697], + "candidate_seconds": 0.0014792222341167786, + "baseline_seconds": 0.001532667521609082, + "reference_seconds": 0.0017281918110148538 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0055906660692382, + "candidate_over_reference": 0.9363815553050643, + "paired_ratio_ci": [1.0023140989070687, 1.0290234035730772], + "candidate_seconds": 0.01235857495062408, + "baseline_seconds": 0.012289866411481939, + "reference_seconds": 0.013198225531682727 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0093496316903157, + "candidate_over_reference": 1.005048260907282, + "paired_ratio_ci": [1.0069546634979778, 1.015660351568457], + "candidate_seconds": 0.1507930500443936, + "baseline_seconds": 0.14939625012976604, + "reference_seconds": 0.15003563103354758 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9562403078137667, + "candidate_over_reference": 0.8199773807292917, + "paired_ratio_ci": [0.9345527143474865, 0.9777235235089239], + "candidate_seconds": 0.0016303772406120385, + "baseline_seconds": 0.001704986944484214, + "reference_seconds": 0.0019883197743356938 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.000856511831646, + "candidate_over_reference": 0.5321256194696841, + "paired_ratio_ci": [0.9876932356037234, 1.0043490787886675], + "candidate_seconds": 0.015054643309364716, + "baseline_seconds": 0.01504175986407236, + "reference_seconds": 0.028291521322292585 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.005781085752714, + "candidate_over_reference": 0.5528146230928795, + "paired_ratio_ci": [1.0043208322296335, 1.01344063087168], + "candidate_seconds": 0.1616986243198404, + "baseline_seconds": 0.16076920376647086, + "reference_seconds": 0.2925006278147477 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9540569320572516, + "candidate_over_reference": 1.2810944702742588, + "paired_ratio_ci": [0.9201054504133414, 0.9832655414449594], + "candidate_seconds": 0.0014637106297803776, + "baseline_seconds": 0.0015341963153332472, + "reference_seconds": 0.0011425469891123829 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9755501239041676, + "candidate_over_reference": 0.9776462641560539, + "paired_ratio_ci": [0.9479150833659313, 1.0567131881843346], + "candidate_seconds": 0.002005630416706914, + "baseline_seconds": 0.0020558968397034775, + "reference_seconds": 0.002051488856696302 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9931431116220236, + "candidate_over_reference": 0.834021572952955, + "paired_ratio_ci": [0.9733094086256953, 1.0068432336183566], + "candidate_seconds": 0.008815352716261432, + "baseline_seconds": 0.008876215938168267, + "reference_seconds": 0.010569693880998307 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9597635409570391, + "candidate_over_reference": 1.2902864565722145, + "paired_ratio_ci": [0.9420468522125967, 0.9924705016568465], + "candidate_seconds": 0.0014666944320890166, + "baseline_seconds": 0.0015281831091713337, + "reference_seconds": 0.0011367200086602853 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9767735303158851, + "candidate_over_reference": 1.0727332404116379, + "paired_ratio_ci": [0.9723860868405443, 0.9961550460380271], + "candidate_seconds": 0.0022974549570963496, + "baseline_seconds": 0.0023520856020262555, + "reference_seconds": 0.0021416833845987206 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9887678128994808, + "candidate_over_reference": 1.0135302230347782, + "paired_ratio_ci": [0.9735680011565404, 0.9914564195738627], + "candidate_seconds": 0.011692286823831853, + "baseline_seconds": 0.01182510865674842, + "reference_seconds": 0.011536199472001976 + } + ] + }, + "compact-evaluation": { + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 60, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 30, + "control_p95_factor": 1.0185023160358915, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "1f10d4fedb89ac73095680960ae3d306315e39d8ba4370fb3a3e49d2e855ab2d" + }, + "builds": [ + { + "source": { + "revision": "bb5f0ddfafbd1e76c6dc9fb11bc3ccdf0c66192f", + "tree": "7dc9cf5ee9019f93f6a374fedab9e3d5e84b8fae", + "clean": true + }, + "sha256": "7e752ab4da15fc0bc8b537567c554a50a5e4e0b19f9704dd95d55aa402bb638a", + "bytes": 18466784, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 13.558527261018753, + "completed_at": "2026-11-07T18:36:58.152479+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "c97326cdec67667233e671cdadbb9ea19d333154", + "tree": "880d7109ba13c527d4b652e4816efd932b777969", + "clean": true + }, + "sha256": "7bf484e503e40886750188279c8d8b9130a1d0aa81a06cc08e102b9a598ec132", + "bytes": 18460464, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 18.718322283006273, + "completed_at": "2026-11-07T18:31:05.710190+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "compact-evaluation", + "contract_sha256": "1f10d4fedb89ac73095680960ae3d306315e39d8ba4370fb3a3e49d2e855ab2d", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 60, + "validated_invocations": 5040, + "numeric_fields": 300, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9960701704003385, + "candidate_over_reference": 1.4284840316634806, + "paired_ratio_ci": [0.9739088855531473, 1.0135622262926494], + "candidate_seconds": 0.001357008514571048, + "baseline_seconds": 0.0013623623665244807, + "reference_seconds": 0.0009499640769458243 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.981672310163045, + "candidate_over_reference": 1.2986493147808555, + "paired_ratio_ci": [0.9706992425755337, 1.0186309720964666], + "candidate_seconds": 0.0036930584271127978, + "baseline_seconds": 0.00376200733063299, + "reference_seconds": 0.0028437688181708965 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9932594010297838, + "candidate_over_reference": 1.0800583950431482, + "paired_ratio_ci": [0.9886933424905902, 0.9982889830945654], + "candidate_seconds": 0.043085421435534954, + "baseline_seconds": 0.04337781388312578, + "reference_seconds": 0.03989175181015439 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9880832483885891, + "candidate_over_reference": 1.401607391604029, + "paired_ratio_ci": [0.9677336601676051, 1.0172930337249952], + "candidate_seconds": 0.0014949023468597304, + "baseline_seconds": 0.0015129315766638943, + "reference_seconds": 0.001066562830514851 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9792443824587115, + "candidate_over_reference": 1.2917680191296785, + "paired_ratio_ci": [0.9565615342307507, 0.9949399203089115], + "candidate_seconds": 0.0062580636003986, + "baseline_seconds": 0.006390706663729534, + "reference_seconds": 0.004844572328563247 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.988779554605551, + "candidate_over_reference": 1.1767745582209976, + "paired_ratio_ci": [0.9842835699584083, 0.9964622481640677], + "candidate_seconds": 0.05963732589901026, + "baseline_seconds": 0.06031407670317484, + "reference_seconds": 0.05067863294832586 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.994919074833359, + "candidate_over_reference": 1.4026411635327654, + "paired_ratio_ci": [0.9764784458387755, 1.0107423786031484], + "candidate_seconds": 0.0013576220621221832, + "baseline_seconds": 0.0013645552653109743, + "reference_seconds": 0.0009679040494596674 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9681455384487637, + "candidate_over_reference": 1.1929290202537817, + "paired_ratio_ci": [0.9491428313689023, 0.9871167018473802], + "candidate_seconds": 0.00399308965452725, + "baseline_seconds": 0.004124472505368647, + "reference_seconds": 0.0033472986126850757 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9774399753609152, + "candidate_over_reference": 1.0114599178798345, + "paired_ratio_ci": [0.9736253744851813, 0.9808406559049089], + "candidate_seconds": 0.04645279051536428, + "baseline_seconds": 0.04752495466354525, + "reference_seconds": 0.04592647686201547 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9868766662386153, + "candidate_over_reference": 1.3713302274383345, + "paired_ratio_ci": [0.956755018125927, 1.0051901287147114], + "candidate_seconds": 0.001471026850465153, + "baseline_seconds": 0.001490588338735203, + "reference_seconds": 0.0010727006675941603 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9725094765714712, + "candidate_over_reference": 1.1637852777049216, + "paired_ratio_ci": [0.9560359080259813, 0.9870976142108858], + "candidate_seconds": 0.005367207972865019, + "baseline_seconds": 0.005518926141251411, + "reference_seconds": 0.004611854158741023 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9850166452513154, + "candidate_over_reference": 1.0760787939734662, + "paired_ratio_ci": [0.980194144043591, 0.9895304779859797], + "candidate_seconds": 0.05517518433320913, + "baseline_seconds": 0.05601446899319334, + "reference_seconds": 0.05127429760926004 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9911793573245873, + "candidate_over_reference": 1.3888928269651704, + "paired_ratio_ci": [0.9678590222953825, 1.0212404754583022], + "candidate_seconds": 0.0013983518417392457, + "baseline_seconds": 0.001410795968868548, + "reference_seconds": 0.0010068104713268223 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9725966328735832, + "candidate_over_reference": 1.1281754168492508, + "paired_ratio_ci": [0.9658072722235651, 0.9968149642503271], + "candidate_seconds": 0.008742586138569527, + "baseline_seconds": 0.008988912610913672, + "reference_seconds": 0.0077493145197097745 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9810749006617417, + "candidate_over_reference": 1.0467605025757387, + "paired_ratio_ci": [0.977534831968222, 0.9864894402066628], + "candidate_seconds": 0.11619571343042134, + "baseline_seconds": 0.11843714822593722, + "reference_seconds": 0.11100506099007491 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9829700060037648, + "candidate_over_reference": 1.3691218402161425, + "paired_ratio_ci": [0.9539994671727269, 1.0340879527044533], + "candidate_seconds": 0.0015150746607798197, + "baseline_seconds": 0.0015413233888379875, + "reference_seconds": 0.001106603237401162 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9861998317601226, + "candidate_over_reference": 1.2868496986112568, + "paired_ratio_ci": [0.9720019835869256, 1.0089989266677901], + "candidate_seconds": 0.012463862980006351, + "baseline_seconds": 0.012638273277497362, + "reference_seconds": 0.009685562341473997 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9876704877053106, + "candidate_over_reference": 1.239644613585727, + "paired_ratio_ci": [0.9738725189237947, 0.9905059417863752], + "candidate_seconds": 0.13413260275653252, + "baseline_seconds": 0.13580703729253618, + "reference_seconds": 0.10820246487301552 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9824020703963259, + "candidate_over_reference": 0.8511907849525704, + "paired_ratio_ci": [0.9650410990799775, 1.033611959224111], + "candidate_seconds": 0.0014632972833212641, + "baseline_seconds": 0.0014895095678401134, + "reference_seconds": 0.0017191178631037474 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9804135887279092, + "candidate_over_reference": 0.8998997381871429, + "paired_ratio_ci": [0.959514912963628, 0.9878320876517765], + "candidate_seconds": 0.01215424782241739, + "baseline_seconds": 0.012397061772866263, + "reference_seconds": 0.013506224423292138 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9849950991479299, + "candidate_over_reference": 0.9751194712796059, + "paired_ratio_ci": [0.9405323559910314, 1.0019924004684322], + "candidate_seconds": 0.14757443860261923, + "baseline_seconds": 0.14982251051835538, + "reference_seconds": 0.15133985419136783 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9965632728667736, + "candidate_over_reference": 0.8213980647038762, + "paired_ratio_ci": [0.952379628782746, 1.004966368568974], + "candidate_seconds": 0.001608120964928752, + "baseline_seconds": 0.001613666697050489, + "reference_seconds": 0.0019577851884865333 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9805999190209678, + "candidate_over_reference": 0.5202978121661275, + "paired_ratio_ci": [0.9513964353595445, 0.9849261160117339], + "candidate_seconds": 0.014739606535017845, + "baseline_seconds": 0.015031213290058076, + "reference_seconds": 0.028329172620682845 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9864755171026816, + "candidate_over_reference": 0.541738192681049, + "paired_ratio_ci": [0.9830129956281165, 0.9942064555660409], + "candidate_seconds": 0.15980814514304734, + "baseline_seconds": 0.16199909918941557, + "reference_seconds": 0.2949914687612493 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9909939578524048, + "candidate_over_reference": 1.2854080416365, + "paired_ratio_ci": [0.9735830401197829, 1.0337870505869304], + "candidate_seconds": 0.001439534959250263, + "baseline_seconds": 0.0014526172918045805, + "reference_seconds": 0.0011199050516422307 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.978193677561458, + "candidate_over_reference": 0.9294213664766721, + "paired_ratio_ci": [0.9427336333595114, 0.9855194846352864], + "candidate_seconds": 0.0020278688974767214, + "baseline_seconds": 0.002073075040243566, + "reference_seconds": 0.0021818617159234627 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9868530798283942, + "candidate_over_reference": 0.8285908753308356, + "paired_ratio_ci": [0.978694294850959, 0.995243656952904], + "candidate_seconds": 0.008729941865784071, + "baseline_seconds": 0.008846242712544543, + "reference_seconds": 0.010535889454851193 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9884341972576354, + "candidate_over_reference": 1.282716680013673, + "paired_ratio_ci": [0.9753870019554342, 1.0236444105817613], + "candidate_seconds": 0.0014751355352234981, + "baseline_seconds": 0.001492396296401109, + "reference_seconds": 0.0011500088509083504 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.979959711484567, + "candidate_over_reference": 1.092501700070336, + "paired_ratio_ci": [0.9572426759899659, 0.9859482754254939], + "candidate_seconds": 0.0022634597983033885, + "baseline_seconds": 0.002309747810830318, + "reference_seconds": 0.0020718135250111422 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9967093304520748, + "candidate_over_reference": 1.0273093930551214, + "paired_ratio_ci": [0.9842240722978225, 1.0260663388129296], + "candidate_seconds": 0.011670137251106402, + "baseline_seconds": 0.011708666603746158, + "reference_seconds": 0.01135990513666045 + } + ] + }, + "record-buffer-qualified": { + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 60, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 30, + "control_p95_factor": 1.01364087045511, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "0c6909b6e776f06189eb039cd80e0f02d3106fad4c3c22b80397c48d52ba4c02" + }, + "builds": [ + { + "source": { + "revision": "bc116da15d1983c158729961e3106ea54559519e", + "tree": "28a72cd52e1b5f9a0c31af9a5f22bdd7cea891aa", + "clean": true + }, + "sha256": "ce57698c9ee19c07a2aa23932386f5457111042aa0b9cc7644e8edfe12e0a5ac", + "bytes": 18471504, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 14.549756912980229, + "completed_at": "2026-11-07T18:45:34.958828+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "bb5f0ddfafbd1e76c6dc9fb11bc3ccdf0c66192f", + "tree": "7dc9cf5ee9019f93f6a374fedab9e3d5e84b8fae", + "clean": true + }, + "sha256": "7e752ab4da15fc0bc8b537567c554a50a5e4e0b19f9704dd95d55aa402bb638a", + "bytes": 18466784, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 13.558527261018753, + "completed_at": "2026-11-07T18:36:58.152479+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "record-buffer-qualified", + "contract_sha256": "0c6909b6e776f06189eb039cd80e0f02d3106fad4c3c22b80397c48d52ba4c02", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 60, + "validated_invocations": 5040, + "numeric_fields": 300, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9754458648851028, + "candidate_over_reference": 1.4208875086476436, + "paired_ratio_ci": [0.9614950161705105, 0.9877026970149312], + "candidate_seconds": 0.0013581868593714067, + "baseline_seconds": 0.0013923754339062032, + "reference_seconds": 0.0009558721933336485 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9719191156006838, + "candidate_over_reference": 1.342640495018795, + "paired_ratio_ci": [0.9633087255502789, 0.9919305977145435], + "candidate_seconds": 0.003731528147389846, + "baseline_seconds": 0.0038393402161697545, + "reference_seconds": 0.002779245942032763 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9866392582482842, + "candidate_over_reference": 1.1009403937879396, + "paired_ratio_ci": [0.9813775143282183, 0.9925240545265288], + "candidate_seconds": 0.03989811818714121, + "baseline_seconds": 0.04043840527689705, + "reference_seconds": 0.03624003480321595 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9752484656065862, + "candidate_over_reference": 1.3855513834246318, + "paired_ratio_ci": [0.9583226187619207, 0.9869418306464248], + "candidate_seconds": 0.00149038147979549, + "baseline_seconds": 0.0015282069465943746, + "reference_seconds": 0.0010756594794137137 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9837793372279441, + "candidate_over_reference": 1.3189161858232745, + "paired_ratio_ci": [0.9686972220729145, 0.9922313127931425], + "candidate_seconds": 0.006057333434000611, + "baseline_seconds": 0.006157207419164479, + "reference_seconds": 0.004592659866570362 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9811133473141134, + "candidate_over_reference": 1.1683206791166405, + "paired_ratio_ci": [0.9771588329927491, 0.9835570545366534], + "candidate_seconds": 0.05888084879898954, + "baseline_seconds": 0.06001431838653627, + "reference_seconds": 0.050397848682699815 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9835573608356274, + "candidate_over_reference": 1.401437769023054, + "paired_ratio_ci": [0.9692291010178369, 0.9901027449076069], + "candidate_seconds": 0.0013568038508916895, + "baseline_seconds": 0.00137948624545797, + "reference_seconds": 0.0009681513377775749 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9738622064422977, + "candidate_over_reference": 1.1947318869071113, + "paired_ratio_ci": [0.9585493277142021, 1.0523378646830328], + "candidate_seconds": 0.004095331277875673, + "baseline_seconds": 0.004205247160002944, + "reference_seconds": 0.0034278245376689093 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9841856521040758, + "candidate_over_reference": 1.020709739769406, + "paired_ratio_ci": [0.9678335493560113, 0.9850923593617984], + "candidate_seconds": 0.04313977997905264, + "baseline_seconds": 0.043832969812986754, + "reference_seconds": 0.04226449332089119 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9838561315892967, + "candidate_over_reference": 1.3841840514396853, + "paired_ratio_ci": [0.9414405745836196, 1.031263833528713], + "candidate_seconds": 0.0015082629397511482, + "baseline_seconds": 0.0015330116785619232, + "reference_seconds": 0.001089640455098734 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9727170757943396, + "candidate_over_reference": 1.1555421266490045, + "paired_ratio_ci": [0.9644895684326109, 0.9841884888080339], + "candidate_seconds": 0.005370368438196324, + "baseline_seconds": 0.005520997391570182, + "reference_seconds": 0.004647488234609011 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9895582351331207, + "candidate_over_reference": 1.0705666397204368, + "paired_ratio_ci": [0.9845301339955665, 0.9966763982367997], + "candidate_seconds": 0.05468417808879167, + "baseline_seconds": 0.05526120257231274, + "reference_seconds": 0.05107965824815134 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9694874657099659, + "candidate_over_reference": 1.3998543224092597, + "paired_ratio_ci": [0.9443968387006375, 0.9876428397884767], + "candidate_seconds": 0.0014313697659720976, + "baseline_seconds": 0.0014764190529517475, + "reference_seconds": 0.0010225133737549186 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.983943214520203, + "candidate_over_reference": 1.115806428473358, + "paired_ratio_ci": [0.9740459012678865, 0.9976079631302752], + "candidate_seconds": 0.008752959325820917, + "baseline_seconds": 0.008895797233673789, + "reference_seconds": 0.00784451415806654 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9937283908029835, + "candidate_over_reference": 1.0395719833639068, + "paired_ratio_ci": [0.9900128629101206, 0.9978051266872622], + "candidate_seconds": 0.11107747634828445, + "baseline_seconds": 0.11177850746372271, + "reference_seconds": 0.10684924000053711 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9812688919864921, + "candidate_over_reference": 1.3702371688198898, + "paired_ratio_ci": [0.9683579533843095, 0.9934688582009392], + "candidate_seconds": 0.0015242887505640585, + "baseline_seconds": 0.0015533853799015993, + "reference_seconds": 0.0011124269471370748 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9889988344090059, + "candidate_over_reference": 1.2720042013314807, + "paired_ratio_ci": [0.98342248365563, 1.0041036182593144], + "candidate_seconds": 0.012173739794109548, + "baseline_seconds": 0.012309154844842851, + "reference_seconds": 0.009570518541815025 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9901727421607339, + "candidate_over_reference": 1.2187274655228018, + "paired_ratio_ci": [0.987199915881769, 0.9926071672360522], + "candidate_seconds": 0.13166446066350632, + "baseline_seconds": 0.13297120296019352, + "reference_seconds": 0.1080343755172743 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9737527315775281, + "candidate_over_reference": 0.8474403050383889, + "paired_ratio_ci": [0.9543715825640731, 0.9824106660699546], + "candidate_seconds": 0.001473252866638913, + "baseline_seconds": 0.0015129640399079239, + "reference_seconds": 0.0017384739171358802 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0012679939166396, + "candidate_over_reference": 0.9096731066834945, + "paired_ratio_ci": [0.9901113894328294, 1.0062191218969287], + "candidate_seconds": 0.011773915434744032, + "baseline_seconds": 0.011759005087826933, + "reference_seconds": 0.012943018044877266 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0050271590293027, + "candidate_over_reference": 0.9783253378769431, + "paired_ratio_ci": [1.001178183836162, 1.0081488017187665], + "candidate_seconds": 0.14303705689962953, + "baseline_seconds": 0.14232158366524214, + "reference_seconds": 0.14620602304958516 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9820577186974982, + "candidate_over_reference": 0.821556313549411, + "paired_ratio_ci": [0.9702211563519552, 0.992868675013393], + "candidate_seconds": 0.0016112661909400707, + "baseline_seconds": 0.0016407041666319682, + "reference_seconds": 0.001961236453748175 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9979711125437172, + "candidate_over_reference": 0.5197080820160869, + "paired_ratio_ci": [0.9758301161101541, 1.0051544778589871], + "candidate_seconds": 0.014467177530085402, + "baseline_seconds": 0.014496589478637491, + "reference_seconds": 0.02783712247453098 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0041030504142545, + "candidate_over_reference": 0.5467782714856108, + "paired_ratio_ci": [0.9973391679277985, 1.0085967296798892], + "candidate_seconds": 0.1593683089539852, + "baseline_seconds": 0.15871708475363752, + "reference_seconds": 0.2914678897553434 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9841438441650088, + "candidate_over_reference": 1.2644391687770251, + "paired_ratio_ci": [0.9670790492477945, 0.9983422776803069], + "candidate_seconds": 0.0014310295061607445, + "baseline_seconds": 0.0014540857158689981, + "reference_seconds": 0.0011317503771611623 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9756300924697019, + "candidate_over_reference": 0.952003715405682, + "paired_ratio_ci": [0.9639885773088368, 0.9839701746794948], + "candidate_seconds": 0.002000526613777592, + "baseline_seconds": 0.002050497036959444, + "reference_seconds": 0.0021013853007129262 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9802252510525253, + "candidate_over_reference": 0.8342087490342585, + "paired_ratio_ci": [0.97306065241795, 0.9837418901062828], + "candidate_seconds": 0.008513072422439498, + "baseline_seconds": 0.00868481240745279, + "reference_seconds": 0.010204966601339124 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9678217720973141, + "candidate_over_reference": 1.2719312289286138, + "paired_ratio_ci": [0.9482779120317432, 0.9776890243346779], + "candidate_seconds": 0.0014122129539914784, + "baseline_seconds": 0.001459166341062103, + "reference_seconds": 0.0011102903379304778 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9737667033575422, + "candidate_over_reference": 1.0884492230882095, + "paired_ratio_ci": [0.9627153656155334, 0.9968605055436055], + "candidate_seconds": 0.002242098107845301, + "baseline_seconds": 0.002302500280729007, + "reference_seconds": 0.0020599014269897624 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9868448770263907, + "candidate_over_reference": 1.0329430810449942, + "paired_ratio_ci": [0.9671178971564502, 0.9888735232842271], + "candidate_seconds": 0.011213640288804613, + "baseline_seconds": 0.011363123576822025, + "reference_seconds": 0.01085600987564595 + } + ] + }, + "directory-prefix": { + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 60, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 30, + "control_p95_factor": 1.026882274785694, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "7fb1aac8bb1217f51504c457f29ad1c0912f3456eee564a06996be40954fae5e" + }, + "builds": [ + { + "source": { + "revision": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "tree": "334ec6a7c02868e97a6cf06077da7b2158801b10", + "clean": true + }, + "sha256": "c622f2352528be0de99eb41f87fc9e4b2e69b732745a0f4583c71156471f54cc", + "bytes": 18472096, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 7.262214220012538, + "completed_at": "2026-11-07T18:50:36.341684+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "bc116da15d1983c158729961e3106ea54559519e", + "tree": "28a72cd52e1b5f9a0c31af9a5f22bdd7cea891aa", + "clean": true + }, + "sha256": "ce57698c9ee19c07a2aa23932386f5457111042aa0b9cc7644e8edfe12e0a5ac", + "bytes": 18471504, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 14.549756912980229, + "completed_at": "2026-11-07T18:45:34.958828+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "directory-prefix", + "contract_sha256": "7fb1aac8bb1217f51504c457f29ad1c0912f3456eee564a06996be40954fae5e", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 60, + "validated_invocations": 5040, + "numeric_fields": 300, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9615139070626089, + "candidate_over_reference": 1.4150128524971934, + "paired_ratio_ci": [0.9479921516408566, 0.9703979855658662], + "candidate_seconds": 0.0013492564681828732, + "baseline_seconds": 0.0014032625615419377, + "reference_seconds": 0.000953529479115137 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9854364402966285, + "candidate_over_reference": 1.3417501379425443, + "paired_ratio_ci": [0.9590402208704986, 0.9916317040454233], + "candidate_seconds": 0.003711153409399447, + "baseline_seconds": 0.003765999771920698, + "reference_seconds": 0.0027659049956128 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9852167487856567, + "candidate_over_reference": 1.0926270872297217, + "paired_ratio_ci": [0.979548279323158, 0.9882480548267456], + "candidate_seconds": 0.039420740823039695, + "baseline_seconds": 0.04001225199594739, + "reference_seconds": 0.036078861016514044 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9698406656697992, + "candidate_over_reference": 1.3829688872453951, + "paired_ratio_ci": [0.9402724316335644, 1.0138810965088758], + "candidate_seconds": 0.0014917481845865648, + "baseline_seconds": 0.0015381373842025088, + "reference_seconds": 0.0010786563590435044 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9642381179399521, + "candidate_over_reference": 1.2757903938257305, + "paired_ratio_ci": [0.9559708132680867, 0.9942361597292789], + "candidate_seconds": 0.0061037709515187, + "baseline_seconds": 0.006330148993237387, + "reference_seconds": 0.004784305463545024 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9847071979307738, + "candidate_over_reference": 1.1540841361740353, + "paired_ratio_ci": [0.9769370007462207, 0.9893253030453284], + "candidate_seconds": 0.06080134113186172, + "baseline_seconds": 0.061745604439195065, + "reference_seconds": 0.0526836295778464 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9699043364331095, + "candidate_over_reference": 1.4051659875225708, + "paired_ratio_ci": [0.9362002062215177, 1.007613925065915], + "candidate_seconds": 0.001379081280902028, + "baseline_seconds": 0.0014218735076220973, + "reference_seconds": 0.0009814365656070766 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.975409332582165, + "candidate_over_reference": 1.162539070290645, + "paired_ratio_ci": [0.9395219862644045, 0.9898386514469029], + "candidate_seconds": 0.004022814006367255, + "baseline_seconds": 0.004124231614349853, + "reference_seconds": 0.003460368867741809 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9819200765836783, + "candidate_over_reference": 1.0132682331816467, + "paired_ratio_ci": [0.9724029376553563, 0.9832168746449754], + "candidate_seconds": 0.042234036938420365, + "baseline_seconds": 0.043011684907555935, + "reference_seconds": 0.04168100366258018 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9811165286264746, + "candidate_over_reference": 1.387153244748232, + "paired_ratio_ci": [0.967521282138346, 0.99286715857295], + "candidate_seconds": 0.0014646008522028015, + "baseline_seconds": 0.0014927899076913793, + "reference_seconds": 0.0010558320486563303 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9895266465565427, + "candidate_over_reference": 1.1690085597220785, + "paired_ratio_ci": [0.9774988621748604, 1.0120300715404889], + "candidate_seconds": 0.0052723943677154324, + "baseline_seconds": 0.005328198473545767, + "reference_seconds": 0.004510141798250732 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9860176901102656, + "candidate_over_reference": 1.0611186652409044, + "paired_ratio_ci": [0.9767134689010443, 0.9895304634491482], + "candidate_seconds": 0.054860472318805045, + "baseline_seconds": 0.05563842603338084, + "reference_seconds": 0.051700600616944335 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9709558435976153, + "candidate_over_reference": 1.382687383049293, + "paired_ratio_ci": [0.9449256440386082, 0.9935915011552063], + "candidate_seconds": 0.001400554475064079, + "baseline_seconds": 0.00144244919508873, + "reference_seconds": 0.0010129220040869854 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9844241112259322, + "candidate_over_reference": 1.111436294405588, + "paired_ratio_ci": [0.9794717404733211, 0.9993418211641083], + "candidate_seconds": 0.008554604342429056, + "baseline_seconds": 0.008689958164246664, + "reference_seconds": 0.007696891297763657 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9868387622426096, + "candidate_over_reference": 1.030784280817165, + "paired_ratio_ci": [0.9792717835593182, 0.998633761315666], + "candidate_seconds": 0.10929329809178376, + "baseline_seconds": 0.11075091724550086, + "reference_seconds": 0.10602926347027755 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9694328300113136, + "candidate_over_reference": 1.3802523440571226, + "paired_ratio_ci": [0.9569085120548627, 0.9861996070579658], + "candidate_seconds": 0.0015328715754938976, + "baseline_seconds": 0.0015812045229332788, + "reference_seconds": 0.0011105734267316404 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9881050692649951, + "candidate_over_reference": 1.2637323305080923, + "paired_ratio_ci": [0.9783297816954327, 0.9964541046826177], + "candidate_seconds": 0.012828751051399325, + "baseline_seconds": 0.012983185139351658, + "reference_seconds": 0.01015147807941373 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.992280124282302, + "candidate_over_reference": 1.2248284541947634, + "paired_ratio_ci": [0.9890041365895329, 0.9958283686612475], + "candidate_seconds": 0.13226419438918433, + "baseline_seconds": 0.13329320133752412, + "reference_seconds": 0.10798589299277712 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.981778520448993, + "candidate_over_reference": 0.8505034867292138, + "paired_ratio_ci": [0.9527657724633964, 0.9949435269047123], + "candidate_seconds": 0.0014722936709101002, + "baseline_seconds": 0.0014996189468850691, + "reference_seconds": 0.0017310848149160545 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.988966188548665, + "candidate_over_reference": 0.902144646569532, + "paired_ratio_ci": [0.9790863278053954, 1.0005526747746427], + "candidate_seconds": 0.011813660468240934, + "baseline_seconds": 0.011945464470911594, + "reference_seconds": 0.01309508459997319 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9956947794707833, + "candidate_over_reference": 0.9679777689576998, + "paired_ratio_ci": [0.9929440606996445, 1.0019335771026403], + "candidate_seconds": 0.14223621978557535, + "baseline_seconds": 0.14285122581558035, + "reference_seconds": 0.146941618234407 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.973254497055486, + "candidate_over_reference": 0.8158837006129677, + "paired_ratio_ci": [0.9565587992896416, 0.9912881097078299], + "candidate_seconds": 0.0016286544102643216, + "baseline_seconds": 0.0016734106188994787, + "reference_seconds": 0.001996184516298984 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9746849583386055, + "candidate_over_reference": 0.5233461073876309, + "paired_ratio_ci": [0.9500601275230826, 0.9757465707879245], + "candidate_seconds": 0.014912093845417812, + "baseline_seconds": 0.015299398762484392, + "reference_seconds": 0.02849375133380471 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9911873423767624, + "candidate_over_reference": 0.5495970478022293, + "paired_ratio_ci": [0.9857665250320424, 0.9931751821973719], + "candidate_seconds": 0.16238820324430153, + "baseline_seconds": 0.16383199855530015, + "reference_seconds": 0.2954677502247727 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9715648708478669, + "candidate_over_reference": 1.2626744460193227, + "paired_ratio_ci": [0.9370304720686055, 0.983521223497066], + "candidate_seconds": 0.0014283548031623166, + "baseline_seconds": 0.0014701589631537597, + "reference_seconds": 0.001131213835573622 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.950912567390288, + "candidate_over_reference": 0.9417182473746512, + "paired_ratio_ci": [0.9329956846979547, 0.963377604613905], + "candidate_seconds": 0.0020513691651147035, + "baseline_seconds": 0.0021572637016929333, + "reference_seconds": 0.002178325811179266 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9690340213978131, + "candidate_over_reference": 0.8274141833023234, + "paired_ratio_ci": [0.956028337218149, 0.9750660140882051], + "candidate_seconds": 0.008482087281576935, + "baseline_seconds": 0.008753136726140621, + "reference_seconds": 0.010251319656769434 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9670041086499542, + "candidate_over_reference": 1.2879189781179707, + "paired_ratio_ci": [0.9431693288391607, 0.9836559337663897], + "candidate_seconds": 0.0014784487651749736, + "baseline_seconds": 0.0015288960532329622, + "reference_seconds": 0.0011479361592570232 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9519989075615862, + "candidate_over_reference": 1.045018764129869, + "paired_ratio_ci": [0.8986804195017287, 0.9635867560479573], + "candidate_seconds": 0.0022725059783884455, + "baseline_seconds": 0.002387088850983197, + "reference_seconds": 0.0021746078217845586 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9709455815197057, + "candidate_over_reference": 1.0200331888371776, + "paired_ratio_ci": [0.9678784911926949, 0.9832273610521108], + "candidate_seconds": 0.011350081180266682, + "baseline_seconds": 0.011689719173037225, + "reference_seconds": 0.011127168512237924 + } + ] + }, + "combined": { + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 120, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 60, + "control_p95_factor": 1.016103767267138, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "324c209a817e715532068137ac0f8aa58c7fa3f90db77aa14f5c79d84175cbf4" + }, + "builds": [ + { + "source": { + "revision": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "tree": "334ec6a7c02868e97a6cf06077da7b2158801b10", + "clean": true + }, + "sha256": "c622f2352528be0de99eb41f87fc9e4b2e69b732745a0f4583c71156471f54cc", + "bytes": 18472096, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 0.7000186709919944, + "completed_at": "2026-11-07T18:54:52.779121+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "90abd2b3ef63b35833e8f9d96745475c6b9f182a", + "tree": "3033d042fc343d55c7e62b322ea394f645b38559", + "clean": true + }, + "sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "bytes": 18457800, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 20.564833533018827, + "completed_at": "2026-11-07T15:48:41.518725+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "combined", + "contract_sha256": "324c209a817e715532068137ac0f8aa58c7fa3f90db77aa14f5c79d84175cbf4", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 120, + "validated_invocations": 10080, + "numeric_fields": 600, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9753261179103341, + "candidate_over_reference": 1.4299927030585613, + "paired_ratio_ci": [0.9533485235058428, 0.988002943997293], + "candidate_seconds": 0.0013503006581837933, + "baseline_seconds": 0.0013844606777032216, + "reference_seconds": 0.0009442710129189349 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9847236648008474, + "candidate_over_reference": 1.4363258943763402, + "paired_ratio_ci": [0.9726937133289643, 1.0047490477828787], + "candidate_seconds": 0.0014113533210807613, + "baseline_seconds": 0.0014332480994718416, + "reference_seconds": 0.0009826135744030278 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9792892729992234, + "candidate_over_reference": 1.3644199228418448, + "paired_ratio_ci": [0.9624261290635879, 0.9885970388371464], + "candidate_seconds": 0.0036107856126147368, + "baseline_seconds": 0.0036871491521153423, + "reference_seconds": 0.0026463888075557492 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0077600144687915, + "candidate_over_reference": 1.3879917523509109, + "paired_ratio_ci": [0.9631582579570331, 1.0272467651462707], + "candidate_seconds": 0.004020436755603268, + "baseline_seconds": 0.00398947834591603, + "reference_seconds": 0.002896585479556095 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9853543285478374, + "candidate_over_reference": 1.0935211542271726, + "paired_ratio_ci": [0.9810463370740142, 0.9881135594225838], + "candidate_seconds": 0.0393217473313035, + "baseline_seconds": 0.03990620043173078, + "reference_seconds": 0.03595883552805476 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9926447967170614, + "candidate_over_reference": 1.1097124304068744, + "paired_ratio_ci": [0.9841193561383624, 1.0027970106732145], + "candidate_seconds": 0.0396843807261792, + "baseline_seconds": 0.039978430207286565, + "reference_seconds": 0.03576095900054844 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0012672054003238, + "candidate_over_reference": 1.42991863543537, + "paired_ratio_ci": [0.9886948348699635, 1.0191648086087355], + "candidate_seconds": 0.001497822131828538, + "baseline_seconds": 0.0014959264857073624, + "reference_seconds": 0.0010474876644799398 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9623548262684675, + "candidate_over_reference": 1.4020713169925947, + "paired_ratio_ci": [0.940119643942811, 0.9848668021381582], + "candidate_seconds": 0.0015391322861736019, + "baseline_seconds": 0.0015993397073110654, + "reference_seconds": 0.0010977560609933875 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9724625224913354, + "candidate_over_reference": 1.3429063468710316, + "paired_ratio_ci": [0.9643713671157711, 0.9864276425693815], + "candidate_seconds": 0.005989045342652216, + "baseline_seconds": 0.006158638717828407, + "reference_seconds": 0.004459763971334766 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9499561656088659, + "candidate_over_reference": 1.3245969072196002, + "paired_ratio_ci": [0.915586665574251, 0.9811896364790703], + "candidate_seconds": 0.005529333194274278, + "baseline_seconds": 0.005820619302713091, + "reference_seconds": 0.004174351581327972 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9732254398581404, + "candidate_over_reference": 1.1647236241381083, + "paired_ratio_ci": [0.9694460344238951, 0.9781826140175085], + "candidate_seconds": 0.05814134097281134, + "baseline_seconds": 0.05974087666808849, + "reference_seconds": 0.0499185727565505 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9600749640888789, + "candidate_over_reference": 1.1702832613738157, + "paired_ratio_ci": [0.9333543030260735, 0.9634111461602592], + "candidate_seconds": 0.04964765919084173, + "baseline_seconds": 0.05171227357017675, + "reference_seconds": 0.04242362582590431 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9923345168446513, + "candidate_over_reference": 1.4581359710092314, + "paired_ratio_ci": [0.9699750823496195, 0.9990051989220212], + "candidate_seconds": 0.0013931598458882598, + "baseline_seconds": 0.0014039215831352131, + "reference_seconds": 0.0009554389121365689 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9745379428413193, + "candidate_over_reference": 1.421634513788174, + "paired_ratio_ci": [0.9527395752041619, 1.0123693413907424], + "candidate_seconds": 0.001432978087991831, + "baseline_seconds": 0.0014704179539833041, + "reference_seconds": 0.0010079792478964443 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9543143722995339, + "candidate_over_reference": 1.208778299672321, + "paired_ratio_ci": [0.9496904189521866, 0.9608080231508723], + "candidate_seconds": 0.003783757171948396, + "baseline_seconds": 0.0039648959313386255, + "reference_seconds": 0.003130232543861937 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9339774865006357, + "candidate_over_reference": 1.197699536273945, + "paired_ratio_ci": [0.9130761877819692, 0.9529906799260562], + "candidate_seconds": 0.003924987101483913, + "baseline_seconds": 0.0042024429477307765, + "reference_seconds": 0.003277104968825976 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.963411180075605, + "candidate_over_reference": 1.0166116186451426, + "paired_ratio_ci": [0.9614087297282712, 0.9670605114627443], + "candidate_seconds": 0.041846711099857374, + "baseline_seconds": 0.04343598243957829, + "reference_seconds": 0.041162928233721426 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9355957723893467, + "candidate_over_reference": 1.0089699766404105, + "paired_ratio_ci": [0.9088648385404267, 0.9495491429273145], + "candidate_seconds": 0.04097072675912863, + "baseline_seconds": 0.04379105588997759, + "reference_seconds": 0.04060648751467289 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9656675602499712, + "candidate_over_reference": 1.3682855424714873, + "paired_ratio_ci": [0.9430106653569672, 0.973787886582594], + "candidate_seconds": 0.001423096051439643, + "baseline_seconds": 0.0014736914752228629, + "reference_seconds": 0.0010400578002667143 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9833293583070065, + "candidate_over_reference": 1.3887439184220938, + "paired_ratio_ci": [0.9648641233000218, 1.0060601892125605], + "candidate_seconds": 0.0015770580697183807, + "baseline_seconds": 0.0016037943506879465, + "reference_seconds": 0.001135600342725714 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9603558407978011, + "candidate_over_reference": 1.2052353001810405, + "paired_ratio_ci": [0.9557536619783825, 0.9956235399461054], + "candidate_seconds": 0.0050060514005876725, + "baseline_seconds": 0.005212704695406414, + "reference_seconds": 0.004153588431931678 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9402744783982122, + "candidate_over_reference": 1.1920398046964193, + "paired_ratio_ci": [0.9074980280941252, 0.9716862887237665], + "candidate_seconds": 0.004892311524599791, + "baseline_seconds": 0.005203067441470921, + "reference_seconds": 0.004104151141031512 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9675947598443939, + "candidate_over_reference": 1.066147328852201, + "paired_ratio_ci": [0.9644406118111023, 0.9746836289915835], + "candidate_seconds": 0.05318572933209084, + "baseline_seconds": 0.054966946431834786, + "reference_seconds": 0.049885909660674986 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9619000014687304, + "candidate_over_reference": 1.0784896017811827, + "paired_ratio_ci": [0.9540154389961853, 0.9759305256485034], + "candidate_seconds": 0.04760300366961885, + "baseline_seconds": 0.0494885160587728, + "reference_seconds": 0.044138583803682456 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.981098656914188, + "candidate_over_reference": 1.407534741810495, + "paired_ratio_ci": [0.9661206157286568, 0.9970723286978482], + "candidate_seconds": 0.0014358217595145106, + "baseline_seconds": 0.0014634835644669476, + "reference_seconds": 0.001020096852222369 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9800125204178481, + "candidate_over_reference": 1.4055608401984125, + "paired_ratio_ci": [0.9423735723683645, 1.0303506614845548], + "candidate_seconds": 0.0014449682896069827, + "baseline_seconds": 0.0014744386010404145, + "reference_seconds": 0.0010280368151143193 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9668701455834442, + "candidate_over_reference": 1.1282716170907356, + "paired_ratio_ci": [0.9611401599028585, 0.9740713321688841], + "candidate_seconds": 0.008216507566560591, + "baseline_seconds": 0.008498046613697494, + "reference_seconds": 0.007282384349742816 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9672798496129417, + "candidate_over_reference": 1.127183816058474, + "paired_ratio_ci": [0.9572545584042026, 0.971722198666697], + "candidate_seconds": 0.008704343644369925, + "baseline_seconds": 0.008998785251086312, + "reference_seconds": 0.007722204240659873 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9735188631608352, + "candidate_over_reference": 1.0326952985728275, + "paired_ratio_ci": [0.9715574728612419, 0.976624827591976], + "candidate_seconds": 0.10817473481542297, + "baseline_seconds": 0.1111172458068246, + "reference_seconds": 0.10474990538343609 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9839505141693128, + "candidate_over_reference": 1.0420849383021265, + "paired_ratio_ci": [0.9777206220209766, 0.993411710760001], + "candidate_seconds": 0.1104145599196532, + "baseline_seconds": 0.11221556199182357, + "reference_seconds": 0.10595543209707275 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9802375732537888, + "candidate_over_reference": 1.442785039537254, + "paired_ratio_ci": [0.9504849956844073, 1.0255105581165043], + "candidate_seconds": 0.0016302115261732112, + "baseline_seconds": 0.0016630779829851928, + "reference_seconds": 0.0011299060369353918 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9589234719335905, + "candidate_over_reference": 1.3841145107576944, + "paired_ratio_ci": [0.9445914628595661, 0.9741113560363541], + "candidate_seconds": 0.0016103578687068961, + "baseline_seconds": 0.0016793392964505724, + "reference_seconds": 0.0011634571100806906 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9607736440479435, + "candidate_over_reference": 1.2980205119463428, + "paired_ratio_ci": [0.9456474220900394, 0.9693721048568666], + "candidate_seconds": 0.011604999679894675, + "baseline_seconds": 0.01207880727348051, + "reference_seconds": 0.008940536434584785 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9701662527884582, + "candidate_over_reference": 1.2614838132747626, + "paired_ratio_ci": [0.9202701860743356, 0.9969630613942984], + "candidate_seconds": 0.012307493409718432, + "baseline_seconds": 0.012685963229852774, + "reference_seconds": 0.009756362531334162 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9749926435032445, + "candidate_over_reference": 1.223277203512589, + "paired_ratio_ci": [0.9730130890890006, 0.9759539226182594], + "candidate_seconds": 0.12971173477957823, + "baseline_seconds": 0.13303868049046114, + "reference_seconds": 0.10603625605636764 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.983014556971495, + "candidate_over_reference": 1.211424670787045, + "paired_ratio_ci": [0.9676019145958985, 0.9918314191299453], + "candidate_seconds": 0.13331558703932733, + "baseline_seconds": 0.13561913818453572, + "reference_seconds": 0.1100485983604033 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9916037098990448, + "candidate_over_reference": 0.877216367110095, + "paired_ratio_ci": [0.9769443469079476, 1.0043082765372695], + "candidate_seconds": 0.001531699306464621, + "baseline_seconds": 0.001544668793766981, + "reference_seconds": 0.0017460906612021582 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9902959192871403, + "candidate_over_reference": 0.5797522009119772, + "paired_ratio_ci": [0.9679812771072752, 1.0117393508168284], + "candidate_seconds": 0.0017404281478818682, + "baseline_seconds": 0.0017574829038321262, + "reference_seconds": 0.003002020768776891 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9790016469849743, + "candidate_over_reference": 0.9113311640385234, + "paired_ratio_ci": [0.96876369854742, 0.9836152165419149], + "candidate_seconds": 0.011913656428944142, + "baseline_seconds": 0.012169189363097152, + "reference_seconds": 0.013072807009198837 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9912477293274369, + "candidate_over_reference": 0.6753026454074752, + "paired_ratio_ci": [0.9783314575022735, 1.0295007983460638], + "candidate_seconds": 0.007471801607780868, + "baseline_seconds": 0.0075377742482704065, + "reference_seconds": 0.011064374852659447 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.981708231413093, + "candidate_over_reference": 0.9668006920118256, + "paired_ratio_ci": [0.978603218974214, 0.9860670365483205], + "candidate_seconds": 0.14315403087086798, + "baseline_seconds": 0.14582136146990315, + "reference_seconds": 0.1480698473363494 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.991336802753768, + "candidate_over_reference": 0.892421246554822, + "paired_ratio_ci": [0.9877984089787388, 0.9973451843170031], + "candidate_seconds": 0.08139932632357591, + "baseline_seconds": 0.08211066722980745, + "reference_seconds": 0.09121177542311627 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9869542550007664, + "candidate_over_reference": 0.8355661970663109, + "paired_ratio_ci": [0.9689347485631494, 1.0238796893240787], + "candidate_seconds": 0.0016519484010392002, + "baseline_seconds": 0.0016737841624057009, + "reference_seconds": 0.0019770407262036487 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9852872693521098, + "candidate_over_reference": 0.6283303703205105, + "paired_ratio_ci": [0.9734432614590414, 1.0035917918372765], + "candidate_seconds": 0.0018580671000693525, + "baseline_seconds": 0.0018858125522023155, + "reference_seconds": 0.002957149913224081 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9798218518840988, + "candidate_over_reference": 0.5169262133147116, + "paired_ratio_ci": [0.9574460737526505, 0.9823580405104566], + "candidate_seconds": 0.014364540050294073, + "baseline_seconds": 0.014660358944508647, + "reference_seconds": 0.02778837613628379 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9675006016287773, + "candidate_over_reference": 0.46764541848679425, + "paired_ratio_ci": [0.9361748671506832, 0.9809897577609978], + "candidate_seconds": 0.008857025992169622, + "baseline_seconds": 0.009154543136468246, + "reference_seconds": 0.018939618869418546 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9856784614236012, + "candidate_over_reference": 0.5437691509197988, + "paired_ratio_ci": [0.9848861248480635, 0.9893081506004054], + "candidate_seconds": 0.16013059579944683, + "baseline_seconds": 0.16245723333364973, + "reference_seconds": 0.29448267804192646 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9960163551476598, + "candidate_over_reference": 0.5223733794614923, + "paired_ratio_ci": [0.9816119913514104, 1.0178784063803181], + "candidate_seconds": 0.09085713967769629, + "baseline_seconds": 0.09122052987194842, + "reference_seconds": 0.1739314123766408 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9829499434835905, + "candidate_over_reference": 1.306033538606021, + "paired_ratio_ci": [0.9709924752125931, 0.9947488175376274], + "candidate_seconds": 0.0014468426816165447, + "baseline_seconds": 0.0014719393303883927, + "reference_seconds": 0.001107814339255648 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9886427093228355, + "candidate_over_reference": 1.3736419469926453, + "paired_ratio_ci": [0.9635876764917011, 1.0004864966885216], + "candidate_seconds": 0.0015328607156074473, + "baseline_seconds": 0.0015504698524074186, + "reference_seconds": 0.001115909949432881 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9816609328706184, + "candidate_over_reference": 0.9679751808563394, + "paired_ratio_ci": [0.9682241223217259, 0.9969875026982833], + "candidate_seconds": 0.0020186954255526266, + "baseline_seconds": 0.0020564080304687933, + "reference_seconds": 0.0020854826295925747 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9872203075784275, + "candidate_over_reference": 1.1289039198446864, + "paired_ratio_ci": [0.9544398887174224, 1.009840810188682], + "candidate_seconds": 0.002434376366658225, + "baseline_seconds": 0.0024658896782923313, + "reference_seconds": 0.002156407045688303 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9712652820350508, + "candidate_over_reference": 0.8263420164570556, + "paired_ratio_ci": [0.9623064619142474, 0.9771327873157559], + "candidate_seconds": 0.008601311389135108, + "baseline_seconds": 0.00885577972180077, + "reference_seconds": 0.010408899968578703 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9854077069716632, + "candidate_over_reference": 0.7314529594868304, + "paired_ratio_ci": [0.9719312109263873, 1.0074994651113902], + "candidate_seconds": 0.009577722100186207, + "baseline_seconds": 0.009719552660715721, + "reference_seconds": 0.01309410533646033 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9760864479388375, + "candidate_over_reference": 1.300888317121391, + "paired_ratio_ci": [0.964963444224465, 0.9948045760884597], + "candidate_seconds": 0.0014288953361323191, + "baseline_seconds": 0.0014639024434256413, + "reference_seconds": 0.0010983996991334216 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9789990494442622, + "candidate_over_reference": 1.3823282208588186, + "paired_ratio_ci": [0.9629446524415864, 1.0034012666480276], + "candidate_seconds": 0.0015253068191841954, + "baseline_seconds": 0.0015580268643264259, + "reference_seconds": 0.0011034331761211867 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9808567500926011, + "candidate_over_reference": 1.0823941120621785, + "paired_ratio_ci": [0.9540580164258294, 0.9878581632552844], + "candidate_seconds": 0.002283984767494812, + "baseline_seconds": 0.002328560992498838, + "reference_seconds": 0.0021101230522617698 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9794351560864409, + "candidate_over_reference": 1.1847326617928333, + "paired_ratio_ci": [0.959888134386824, 0.9907718579118513], + "candidate_seconds": 0.002720270095215667, + "baseline_seconds": 0.0027773866174919974, + "reference_seconds": 0.002296104583711851 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9648476363480237, + "candidate_over_reference": 1.0118839268714823, + "paired_ratio_ci": [0.9571631539964505, 0.9726463468997804], + "candidate_seconds": 0.011367601553155552, + "baseline_seconds": 0.01178175820192943, + "reference_seconds": 0.011234096373387036 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9770680099151576, + "candidate_over_reference": 0.8051670250024414, + "paired_ratio_ci": [0.96215680225745, 0.9961689758070128], + "candidate_seconds": 0.012398878550378694, + "baseline_seconds": 0.012689882817323365, + "reference_seconds": 0.015399138520782193 + } + ], + "figure_audit": { + "checked_points": 1440, + "verified_missing_points": 480, + "max_error": 5.551115123125783e-17, + "complete_revisions": 2, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "324c209a817e715532068137ac0f8aa58c7fa3f90db77aa14f5c79d84175cbf4" + }, + "browser_audit": { + "campaign": "find-listing/combined/measurements", + "revisions": 2, + "statesChecked": 24, + "errors": [], + "failedResponses": [] + } + }, + "macos": { + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 120, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 60, + "control_p95_factor": 1.0247841666017916, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "557369095078fcc138b3b1c08525c76cc821f1066da32bd5dbe0f9c45d77245a" + }, + "builds": [ + { + "source": { + "revision": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "tree": "334ec6a7c02868e97a6cf06077da7b2158801b10", + "clean": true + }, + "sha256": "2662daa1f7a8604b339643b1a25bbc9c05c053983296e69b2880d61485dc5c4b", + "bytes": 8278344, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/darwin_arm64-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 23.111399083398283, + "completed_at": "2026-11-07T18:49:07.236573+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "90abd2b3ef63b35833e8f9d96745475c6b9f182a", + "tree": "3033d042fc343d55c7e62b322ea394f645b38559", + "clean": true + }, + "sha256": "e706207e55ac94e252569d3b672c552af7215cf2f3594afff044ea980349d85c", + "bytes": 8277688, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/darwin_arm64-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 147.79824150074273, + "completed_at": "2026-11-07T18:48:44.122852+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "macos", + "contract_sha256": "557369095078fcc138b3b1c08525c76cc821f1066da32bd5dbe0f9c45d77245a", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 120, + "validated_invocations": 10080, + "numeric_fields": 600, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0106297752489783, + "candidate_over_reference": 1.374040630974834, + "paired_ratio_ci": [0.9707777813891733, 1.0463218062216408], + "candidate_seconds": 0.011113071503738562, + "baseline_seconds": 0.010996184533550626, + "reference_seconds": 0.00808787691806044 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9920437145555759, + "candidate_over_reference": 1.3903090509726452, + "paired_ratio_ci": [0.9728627705482416, 1.0132548667027719], + "candidate_seconds": 0.010520446513380324, + "baseline_seconds": 0.010604821500324067, + "reference_seconds": 0.007566984121998151 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9838739575018449, + "candidate_over_reference": 1.38385955651119, + "paired_ratio_ci": [0.9674771830742053, 1.0650010234348162], + "candidate_seconds": 0.013287190525304703, + "baseline_seconds": 0.013504972282264913, + "reference_seconds": 0.00960154552012682 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9893753421016299, + "candidate_over_reference": 1.3607057715730493, + "paired_ratio_ci": [0.9665555043645658, 1.0046504111027112], + "candidate_seconds": 0.011840200273408777, + "baseline_seconds": 0.011967349265302931, + "reference_seconds": 0.008701513964860212 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9577058088944475, + "candidate_over_reference": 0.8442643932057146, + "paired_ratio_ci": [0.9263257390030954, 0.971892896735227], + "candidate_seconds": 0.034055317441622414, + "baseline_seconds": 0.03555926791436616, + "reference_seconds": 0.04033726604566688 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9854183506688968, + "candidate_over_reference": 0.8514631948117051, + "paired_ratio_ci": [0.9585300021488015, 0.9927222115482786], + "candidate_seconds": 0.03507261709975345, + "baseline_seconds": 0.03559160134976819, + "reference_seconds": 0.04119099605651129 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9990262545661958, + "candidate_over_reference": 1.3123574858413127, + "paired_ratio_ci": [0.9857395637736003, 1.0109194220867728], + "candidate_seconds": 0.01120831138853516, + "baseline_seconds": 0.011219236068427563, + "reference_seconds": 0.008540593176370575 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9920589330787537, + "candidate_over_reference": 1.3054202817135927, + "paired_ratio_ci": [0.9576526759473037, 1.0114413536062608], + "candidate_seconds": 0.011393190450256779, + "baseline_seconds": 0.011484388749869097, + "reference_seconds": 0.00872760337023508 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9816868071933857, + "candidate_over_reference": 1.3171453979690249, + "paired_ratio_ci": [0.9722776874634648, 0.9981044413758293], + "candidate_seconds": 0.014379017808962436, + "baseline_seconds": 0.014647255829047589, + "reference_seconds": 0.010916803741738909 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9591478418282859, + "candidate_over_reference": 1.2852773062110898, + "paired_ratio_ci": [0.9222749050773441, 1.0142213071582857], + "candidate_seconds": 0.014501712196284816, + "baseline_seconds": 0.01511937113744872, + "reference_seconds": 0.011282944253512792 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9032469780949168, + "candidate_over_reference": 1.2309837595489583, + "paired_ratio_ci": [0.8999786679338391, 0.9143133158331544], + "candidate_seconds": 0.036024097220173905, + "baseline_seconds": 0.03988288706612019, + "reference_seconds": 0.02926447805726812 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9111925438333297, + "candidate_over_reference": 1.2351991400984161, + "paired_ratio_ci": [0.9049359947801782, 0.9359355514790901], + "candidate_seconds": 0.03646640665829182, + "baseline_seconds": 0.04002052793900172, + "reference_seconds": 0.029522694336871307 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0014116448112096, + "candidate_over_reference": 1.4068543388490493, + "paired_ratio_ci": [0.9918981374342524, 1.0239123861128614], + "candidate_seconds": 0.00992165869545369, + "baseline_seconds": 0.009907672580863749, + "reference_seconds": 0.007052370967964332 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.00848499747369, + "candidate_over_reference": 1.4641618008698398, + "paired_ratio_ci": [0.9793522406384655, 1.0258019051376803], + "candidate_seconds": 0.010195551351422355, + "baseline_seconds": 0.010109769978693553, + "reference_seconds": 0.006963404826819897 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9917703959524528, + "candidate_over_reference": 1.9389636390987375, + "paired_ratio_ci": [0.9743479513399478, 0.9983175512457773], + "candidate_seconds": 0.024967622987571218, + "baseline_seconds": 0.02517480163701943, + "reference_seconds": 0.012876787622060095 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9872977385482314, + "candidate_over_reference": 2.0349727973296954, + "paired_ratio_ci": [0.9595945216499576, 1.0040908024519977], + "candidate_seconds": 0.021851053550129847, + "baseline_seconds": 0.02213218231641111, + "reference_seconds": 0.01073776198817151 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.977173361982963, + "candidate_over_reference": 2.3235915102384435, + "paired_ratio_ci": [0.96311439884535, 1.013155715021733], + "candidate_seconds": 0.1128141526132822, + "baseline_seconds": 0.11544947601145222, + "reference_seconds": 0.04855162885394834 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9814195843945973, + "candidate_over_reference": 2.595583490376146, + "paired_ratio_ci": [0.9634912624481802, 1.0030981118189115], + "candidate_seconds": 0.1279247539738814, + "baseline_seconds": 0.13034664888289713, + "reference_seconds": 0.0492855477191153 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9551787014239818, + "candidate_over_reference": 1.3632307293869765, + "paired_ratio_ci": [0.7495379559510832, 1.0379291210840638], + "candidate_seconds": 0.013845355116895266, + "baseline_seconds": 0.014495041709215869, + "reference_seconds": 0.010156281558530671 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.0159704097707638, + "candidate_over_reference": 1.2923558950203153, + "paired_ratio_ci": [0.9673554391337869, 1.0321265618127087], + "candidate_seconds": 0.012425160878116176, + "baseline_seconds": 0.01222984523822864, + "reference_seconds": 0.00961434920983655 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0032045753231504, + "candidate_over_reference": 1.6787943148332332, + "paired_ratio_ci": [0.9898482789801981, 1.0149081008888654], + "candidate_seconds": 0.023685216282804806, + "baseline_seconds": 0.02360955767688297, + "reference_seconds": 0.014108468246247088 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9910560514110585, + "candidate_over_reference": 2.6699742210906123, + "paired_ratio_ci": [0.9638449913270429, 0.9995018225180498], + "candidate_seconds": 0.0341981528326869, + "baseline_seconds": 0.03450677969626018, + "reference_seconds": 0.012808420606667087 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9879655404401392, + "candidate_over_reference": 2.5130073017047976, + "paired_ratio_ci": [0.9740215228022181, 1.0002366587189562], + "candidate_seconds": 0.11566412298097498, + "baseline_seconds": 0.11707303367022957, + "reference_seconds": 0.046026178635656834 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9900222704367643, + "candidate_over_reference": 3.0996526379155713, + "paired_ratio_ci": [0.9708479243632634, 1.0107607232409281], + "candidate_seconds": 0.14500624606651918, + "baseline_seconds": 0.14646766077549683, + "reference_seconds": 0.04678145037697894 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9970448277233932, + "candidate_over_reference": 1.2303986925798578, + "paired_ratio_ci": [0.9594802907674309, 1.1862556965730302], + "candidate_seconds": 0.01119888871021214, + "baseline_seconds": 0.011232081445909682, + "reference_seconds": 0.00910183729692584 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9867347380321991, + "candidate_over_reference": 1.2919610758806872, + "paired_ratio_ci": [0.9631499152521942, 1.0087735060996328], + "candidate_seconds": 0.01000476193924745, + "baseline_seconds": 0.010139261904571737, + "reference_seconds": 0.007743857091381436 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9914410090191513, + "candidate_over_reference": 0.778270676026445, + "paired_ratio_ci": [0.9755618665615163, 1.0141443636135559], + "candidate_seconds": 0.02247634738506306, + "baseline_seconds": 0.022670382988594827, + "reference_seconds": 0.028879858996896518 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9802506190814185, + "candidate_over_reference": 0.7635397240489786, + "paired_ratio_ci": [0.9240034532213646, 0.9859645489214346], + "candidate_seconds": 0.023130089088919618, + "baseline_seconds": 0.023596097404758137, + "reference_seconds": 0.03029323604312681 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9762490011766578, + "candidate_over_reference": 0.587280730966087, + "paired_ratio_ci": [0.9652427450693988, 0.9862717598321925], + "candidate_seconds": 0.13001825585074367, + "baseline_seconds": 0.13318144827194156, + "reference_seconds": 0.22139029768073842 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9780894841365857, + "candidate_over_reference": 0.5881208892123078, + "paired_ratio_ci": [0.9621210827248555, 0.989171500103355], + "candidate_seconds": 0.12931924410873935, + "baseline_seconds": 0.13221616856753826, + "reference_seconds": 0.21988548014667772 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9888790326108055, + "candidate_over_reference": 1.2488721694907354, + "paired_ratio_ci": [0.9891817938285865, 1.2499615269499673], + "candidate_seconds": 0.010646067648416474, + "baseline_seconds": 0.010765793688950084, + "reference_seconds": 0.008524545512738683 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.0063673052612558, + "candidate_over_reference": 1.2776999914098959, + "paired_ratio_ci": [0.9912093294673705, 1.028357139309786], + "candidate_seconds": 0.011206075593474366, + "baseline_seconds": 0.011135174538053218, + "reference_seconds": 0.008770506119444257 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9961073181441765, + "candidate_over_reference": 0.8651698084428692, + "paired_ratio_ci": [0.9754519584862056, 1.0042625014871618], + "candidate_seconds": 0.026800660593878655, + "baseline_seconds": 0.026905394735790435, + "reference_seconds": 0.03097734147948878 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9851191170322082, + "candidate_over_reference": 0.8686954540601366, + "paired_ratio_ci": [0.9594948704739537, 0.9956399867143944], + "candidate_seconds": 0.026661521799507596, + "baseline_seconds": 0.02706426191365435, + "reference_seconds": 0.030691448510402723 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9795075587854088, + "candidate_over_reference": 0.7583597990299624, + "paired_ratio_ci": [0.9655342617258899, 0.9849100930888225], + "candidate_seconds": 0.16162296446661154, + "baseline_seconds": 0.16500430549716666, + "reference_seconds": 0.21312174600149905 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9840860987746365, + "candidate_over_reference": 0.7603920390706552, + "paired_ratio_ci": [0.9810292603037982, 0.9892338931825915], + "candidate_seconds": 0.16248585132970697, + "baseline_seconds": 0.1651134504714892, + "reference_seconds": 0.21368694434031135 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9922546786276941, + "candidate_over_reference": 1.1390355106365468, + "paired_ratio_ci": [0.9302069008690471, 1.0112896105229645], + "candidate_seconds": 0.010984196460672788, + "baseline_seconds": 0.01106993667781353, + "reference_seconds": 0.009643418803101494 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.0021990326668337, + "candidate_over_reference": 1.091259293199071, + "paired_ratio_ci": [0.967822600217345, 1.0746888645065367], + "candidate_seconds": 0.01112228361446233, + "baseline_seconds": 0.011097879015973635, + "reference_seconds": 0.010192154773644038 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0089141363035037, + "candidate_over_reference": 0.8364141121958157, + "paired_ratio_ci": [0.976052799742809, 1.070138631052759], + "candidate_seconds": 0.08382698410146293, + "baseline_seconds": 0.08308634113165594, + "reference_seconds": 0.1002218672296121 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9897720622547403, + "candidate_over_reference": 0.8247268063114118, + "paired_ratio_ci": [0.9793501084352088, 1.0132575492604612], + "candidate_seconds": 0.05324964473644892, + "baseline_seconds": 0.053799906834250406, + "reference_seconds": 0.06456640469176429 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0163741773949317, + "candidate_over_reference": 0.8736006137146981, + "paired_ratio_ci": [0.9651165296809839, 1.0298193160600737], + "candidate_seconds": 0.9708627162589913, + "baseline_seconds": 0.9552217459394818, + "reference_seconds": 1.1113347461269725 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0127274661638264, + "candidate_over_reference": 0.8892923373312688, + "paired_ratio_ci": [0.958923662190866, 1.042620168018088], + "candidate_seconds": 0.6704019463754126, + "baseline_seconds": 0.6619766608235382, + "reference_seconds": 0.7538600280614836 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.993515712145586, + "candidate_over_reference": 1.0725943585511886, + "paired_ratio_ci": [0.9490980866660185, 1.0092334127206508], + "candidate_seconds": 0.01271051966718265, + "baseline_seconds": 0.012793476249845255, + "reference_seconds": 0.011850257803286825 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9983359111474418, + "candidate_over_reference": 0.9734652397193869, + "paired_ratio_ci": [0.9882081762804726, 1.0158819279157842], + "candidate_seconds": 0.012138974276326951, + "baseline_seconds": 0.012159208279280435, + "reference_seconds": 0.012469858995505742 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.995555058758074, + "candidate_over_reference": 0.6351762130669167, + "paired_ratio_ci": [0.9304222205117748, 1.0138373885135412], + "candidate_seconds": 0.11939863878346625, + "baseline_seconds": 0.1199317282686631, + "reference_seconds": 0.18797718857725462 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.993235694660891, + "candidate_over_reference": 0.8491210599942257, + "paired_ratio_ci": [0.9758897574915756, 1.0314132621986334], + "candidate_seconds": 0.10618204933901627, + "baseline_seconds": 0.10690518867756639, + "reference_seconds": 0.12504936497481095 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0051667723777138, + "candidate_over_reference": 0.6438886758733539, + "paired_ratio_ci": [0.9943469025425252, 1.0549301472043184], + "candidate_seconds": 1.2742973175786791, + "baseline_seconds": 1.2677471565880947, + "reference_seconds": 1.9790646509666527 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9986857935244785, + "candidate_over_reference": 0.8680279356141909, + "paired_ratio_ci": [0.9722744299004444, 1.022407732550906], + "candidate_seconds": 1.0317555695239986, + "baseline_seconds": 1.0331132937045324, + "reference_seconds": 1.1886202358152895 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0300370808080366, + "candidate_over_reference": 1.3128787692975077, + "paired_ratio_ci": [1.000040808063636, 1.0604017817421654], + "candidate_seconds": 0.011036095253768422, + "baseline_seconds": 0.010714269864062468, + "reference_seconds": 0.008406027663676511 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9947097916536634, + "candidate_over_reference": 1.3198790577503383, + "paired_ratio_ci": [0.9660894185782207, 1.064151693415689], + "candidate_seconds": 0.011191760012436481, + "baseline_seconds": 0.011251281636456648, + "reference_seconds": 0.008479382975825242 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 1.007384056081598, + "candidate_over_reference": 1.3381701141665419, + "paired_ratio_ci": [0.9616133734840584, 1.169718919012044], + "candidate_seconds": 0.011178831170712198, + "baseline_seconds": 0.011096891104465439, + "reference_seconds": 0.008353819183650472 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9876562653257642, + "candidate_over_reference": 1.2705825123444472, + "paired_ratio_ci": [0.9687177684358523, 1.005453574945677], + "candidate_seconds": 0.012046980183748971, + "baseline_seconds": 0.012197543423445452, + "reference_seconds": 0.009481462295211497 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9956980334877149, + "candidate_over_reference": 1.1171096145967288, + "paired_ratio_ci": [0.9820479664708652, 1.0474871104455479], + "candidate_seconds": 0.020490793733014948, + "baseline_seconds": 0.02057932530130659, + "reference_seconds": 0.01834268854664905 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9860574895064596, + "candidate_over_reference": 1.087386895904787, + "paired_ratio_ci": [0.9730885591152028, 0.9937936664012107], + "candidate_seconds": 0.01892095050286679, + "baseline_seconds": 0.0191884861726846, + "reference_seconds": 0.01740038488060236 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0038890201408917, + "candidate_over_reference": 1.3424026332845425, + "paired_ratio_ci": [0.987425808429392, 1.0668504229075964], + "candidate_seconds": 0.010891831302571865, + "baseline_seconds": 0.010849636846355029, + "reference_seconds": 0.008113684398787362 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9998318410890339, + "candidate_over_reference": 1.3592738049224447, + "paired_ratio_ci": [0.9799679924191943, 1.0144054481513867], + "candidate_seconds": 0.009981325472749415, + "baseline_seconds": 0.009983004203864507, + "reference_seconds": 0.007343130895779247 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 1.0056443349223616, + "candidate_over_reference": 1.3081680254838957, + "paired_ratio_ci": [0.9798287725563806, 1.0336082711166392], + "candidate_seconds": 0.01126848409573237, + "baseline_seconds": 0.011205237979690233, + "reference_seconds": 0.008613942457096917 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 1.0042349141015858, + "candidate_over_reference": 1.3684536424230485, + "paired_ratio_ci": [0.9755566411182128, 1.016983935433498], + "candidate_seconds": 0.010728404857218266, + "baseline_seconds": 0.01068316258135296, + "reference_seconds": 0.007839801455182689 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.98670236463122, + "candidate_over_reference": 1.1860458299108627, + "paired_ratio_ci": [0.9483752981192315, 0.9982320556894689], + "candidate_seconds": 0.02214779154885383, + "baseline_seconds": 0.02244627391476007, + "reference_seconds": 0.018673638901895002 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9865989925743233, + "candidate_over_reference": 1.1297543132713497, + "paired_ratio_ci": [0.9742168353432881, 0.9982369285284125], + "candidate_seconds": 0.02176529758920272, + "baseline_seconds": 0.022060936361196496, + "reference_seconds": 0.019265514044534592 + } + ], + "figure_audit": { + "checked_points": 1440, + "verified_missing_points": 480, + "max_error": 8.326672684688674e-17, + "complete_revisions": 2, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "557369095078fcc138b3b1c08525c76cc821f1066da32bd5dbe0f9c45d77245a" + }, + "browser_audit": { + "campaign": "find-listing/macos/measurements", + "revisions": 2, + "statesChecked": 24, + "errors": [], + "failedResponses": [] + } + }, + "native-case": { + "baseline": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "candidate": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 120, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 60, + "control_p95_factor": 1.012123452346318, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "82cf932c3695848a3e0f6239453fdb224bf8f8ee95a3b9bf3a2889e607a34a0b" + }, + "builds": [ + { + "source": { + "revision": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "tree": "aa6af8508ed4fc63d352e62bf0222c028acfc884", + "clean": true + }, + "sha256": "b86ee4f2607f60db513dac1829b66867ef7a928edc3b1fdbc777ac4a3efb1cf4", + "bytes": 18477056, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 13.374229129054584, + "completed_at": "2026-11-07T19:18:03.263448+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "tree": "334ec6a7c02868e97a6cf06077da7b2158801b10", + "clean": true + }, + "sha256": "c622f2352528be0de99eb41f87fc9e4b2e69b732745a0f4583c71156471f54cc", + "bytes": 18472096, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 0.7000186709919944, + "completed_at": "2026-11-07T18:54:52.779121+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "native-case", + "contract_sha256": "82cf932c3695848a3e0f6239453fdb224bf8f8ee95a3b9bf3a2889e607a34a0b", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 120, + "validated_invocations": 10080, + "numeric_fields": 600, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9871104502893513, + "candidate_over_reference": 1.4529199538367277, + "paired_ratio_ci": [0.9675333717804353, 1.013159437629058], + "candidate_seconds": 0.0013840491273662164, + "baseline_seconds": 0.0014021218466084627, + "reference_seconds": 0.0009525983339352976 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9864090035120525, + "candidate_over_reference": 1.4334430501246194, + "paired_ratio_ci": [0.9717580207591728, 1.0188424780956922], + "candidate_seconds": 0.0014105180023415457, + "baseline_seconds": 0.0014299524814954826, + "reference_seconds": 0.0009840070048258418 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9879684923605454, + "candidate_over_reference": 1.337047612533619, + "paired_ratio_ci": [0.9622961098605313, 1.012354462725681], + "candidate_seconds": 0.0037519135678719196, + "baseline_seconds": 0.0037976044751260253, + "reference_seconds": 0.0028061181462059417 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9921400060585729, + "candidate_over_reference": 1.3277858616520712, + "paired_ratio_ci": [0.9791259709483817, 1.0067007437823388], + "candidate_seconds": 0.003996964860042291, + "baseline_seconds": 0.004028629866384324, + "reference_seconds": 0.003010248094575391 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9990156879673789, + "candidate_over_reference": 1.094672554408166, + "paired_ratio_ci": [0.9930569138430696, 1.0006003911284378], + "candidate_seconds": 0.04297615218508456, + "baseline_seconds": 0.043018495808133765, + "reference_seconds": 0.039259367572542815 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9967565502116663, + "candidate_over_reference": 1.0958645408591718, + "paired_ratio_ci": [0.9796242367755454, 1.0013106811906316], + "candidate_seconds": 0.04319893630288009, + "baseline_seconds": 0.04333950581383847, + "reference_seconds": 0.039419959942322405 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9980392922823108, + "candidate_over_reference": 1.4372657220679579, + "paired_ratio_ci": [0.9814152592793066, 1.0659231358821961], + "candidate_seconds": 0.0015141898987903481, + "baseline_seconds": 0.0015171646151602978, + "reference_seconds": 0.0010535211934308922 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9717807789946955, + "candidate_over_reference": 1.3940244492628566, + "paired_ratio_ci": [0.9529005225070214, 0.9871023500917605], + "candidate_seconds": 0.0015083878090427745, + "baseline_seconds": 0.001552189384321017, + "reference_seconds": 0.0010820382740348577 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9836660280210373, + "candidate_over_reference": 1.2967288508977488, + "paired_ratio_ci": [0.9686582158217362, 0.993035848170604], + "candidate_seconds": 0.005878927175044304, + "baseline_seconds": 0.005976547941654211, + "reference_seconds": 0.004533659578079269 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9903799336082267, + "candidate_over_reference": 1.3236367934205833, + "paired_ratio_ci": [0.9748496396704436, 1.0306059749241343], + "candidate_seconds": 0.0056458777481956145, + "baseline_seconds": 0.005700719043878573, + "reference_seconds": 0.004265428232472567 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9983997745788775, + "candidate_over_reference": 1.1699780196010559, + "paired_ratio_ci": [0.9942804344704449, 1.0026243562849204], + "candidate_seconds": 0.05642579024147597, + "baseline_seconds": 0.05651622894774413, + "reference_seconds": 0.0482280771913273 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0008508079599485, + "candidate_over_reference": 1.1855861806703627, + "paired_ratio_ci": [0.978446212768208, 1.022293937741417], + "candidate_seconds": 0.048032388562292215, + "baseline_seconds": 0.047991556963617246, + "reference_seconds": 0.04051362047348881 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9822854043658193, + "candidate_over_reference": 1.4519684699364348, + "paired_ratio_ci": [0.9215476420880238, 1.0546006173452356], + "candidate_seconds": 0.0013935654535002652, + "baseline_seconds": 0.001418697098935289, + "reference_seconds": 0.0009597766634431624 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9834119089276621, + "candidate_over_reference": 1.4299339492481973, + "paired_ratio_ci": [0.9490505015661892, 1.0022772490715541], + "candidate_seconds": 0.0014275979649807727, + "baseline_seconds": 0.001451678540823715, + "reference_seconds": 0.000998366369111907 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9933460226984353, + "candidate_over_reference": 1.2097960868121962, + "paired_ratio_ci": [0.9351846145743139, 1.0058566695327347], + "candidate_seconds": 0.003913947857827658, + "baseline_seconds": 0.003940165630497393, + "reference_seconds": 0.003235212859830686 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9806222483205458, + "candidate_over_reference": 1.1667241535459953, + "paired_ratio_ci": [0.9455830852549056, 1.0152477882302722], + "candidate_seconds": 0.004159430579637133, + "baseline_seconds": 0.004241623710619197, + "reference_seconds": 0.0035650505451485515 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0014187430034682, + "candidate_over_reference": 1.020921542036828, + "paired_ratio_ci": [0.9977973617266488, 1.0035542538223217], + "candidate_seconds": 0.045948716623353814, + "baseline_seconds": 0.0458836195591305, + "reference_seconds": 0.045007098715619316 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9990313964227895, + "candidate_over_reference": 1.0044915584539669, + "paired_ratio_ci": [0.9882049151038386, 1.0074823832092648], + "candidate_seconds": 0.04479334823277202, + "baseline_seconds": 0.04483677729565118, + "reference_seconds": 0.0445930559154866 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9811583007557, + "candidate_over_reference": 1.4011475914871578, + "paired_ratio_ci": [0.9550749415940326, 1.0116534413758471], + "candidate_seconds": 0.0014793170959733072, + "baseline_seconds": 0.0015077252007488693, + "reference_seconds": 0.001055789629130491 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9987785695158469, + "candidate_over_reference": 1.4194725446515848, + "paired_ratio_ci": [0.9854000854068626, 1.0118536120754997], + "candidate_seconds": 0.0015768198119032952, + "baseline_seconds": 0.0015787481430119701, + "reference_seconds": 0.0011108491093009 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.006909904353403, + "candidate_over_reference": 1.2037651392996478, + "paired_ratio_ci": [1.0027837153930133, 1.0223381559467148], + "candidate_seconds": 0.004978234818693073, + "baseline_seconds": 0.004944071755744517, + "reference_seconds": 0.004135553237228166 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9944499481516561, + "candidate_over_reference": 1.1950744199000836, + "paired_ratio_ci": [0.9728879049404734, 1.0232793930569621], + "candidate_seconds": 0.0051251827195907635, + "baseline_seconds": 0.005153786501891557, + "reference_seconds": 0.004288588755852764 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9986881845363371, + "candidate_over_reference": 1.0679129576815944, + "paired_ratio_ci": [0.9964216199797478, 1.002049566314934], + "candidate_seconds": 0.05205961707646826, + "baseline_seconds": 0.0521279993921607, + "reference_seconds": 0.0487489328619891 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0058680441656616, + "candidate_over_reference": 1.0811800133565344, + "paired_ratio_ci": [0.9877858926341913, 1.0219311922187893], + "candidate_seconds": 0.04645653027996775, + "baseline_seconds": 0.04618551165774642, + "reference_seconds": 0.04296835837331379 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9990966543727451, + "candidate_over_reference": 1.4228447014890264, + "paired_ratio_ci": [0.9802312197283333, 1.011444385698495], + "candidate_seconds": 0.0014470331869753344, + "baseline_seconds": 0.00144834153997224, + "reference_seconds": 0.0010170000882464506 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9973079096479902, + "candidate_over_reference": 1.43841571087688, + "paired_ratio_ci": [0.9651447347745272, 1.0245266476092132], + "candidate_seconds": 0.0015387629557933127, + "baseline_seconds": 0.001542916626758164, + "reference_seconds": 0.0010697623393276618 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9715396094098815, + "candidate_over_reference": 1.1056789442225712, + "paired_ratio_ci": [0.9623616653561161, 0.9884037836605442], + "candidate_seconds": 0.008911597331808437, + "baseline_seconds": 0.009172654666361354, + "reference_seconds": 0.008059841763627316 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0004366167716219, + "candidate_over_reference": 1.1198654966337482, + "paired_ratio_ci": [0.9902850355126436, 1.0234110387005118], + "candidate_seconds": 0.009204366981672743, + "baseline_seconds": 0.009200349954577783, + "reference_seconds": 0.008219171864246684 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9993274124320005, + "candidate_over_reference": 1.0331861523668477, + "paired_ratio_ci": [0.9968961165022614, 1.0063627646989208], + "candidate_seconds": 0.11358012239603947, + "baseline_seconds": 0.11365656638961463, + "reference_seconds": 0.10993190543238252 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0052938522314583, + "candidate_over_reference": 1.044008963580432, + "paired_ratio_ci": [0.9889797505691622, 1.0198936919139074], + "candidate_seconds": 0.1170674883261589, + "baseline_seconds": 0.1164510138665459, + "reference_seconds": 0.11213264675877456 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9816300422896815, + "candidate_over_reference": 1.4218971593685168, + "paired_ratio_ci": [0.9744109393331568, 1.0157465510327994], + "candidate_seconds": 0.0015987146734481766, + "baseline_seconds": 0.0016286325851632725, + "reference_seconds": 0.0011243532367405436 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9899066762707469, + "candidate_over_reference": 1.4426499608508923, + "paired_ratio_ci": [0.9493653422121814, 1.0099176257916507], + "candidate_seconds": 0.001738040852138684, + "baseline_seconds": 0.001755762329724218, + "reference_seconds": 0.0012047557614832407 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9958173341213167, + "candidate_over_reference": 1.3060854373319621, + "paired_ratio_ci": [0.9646890146380465, 1.0038494151695432], + "candidate_seconds": 0.011799555837309786, + "baseline_seconds": 0.011849116733563798, + "reference_seconds": 0.009034290943028671 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9978123028891053, + "candidate_over_reference": 1.2687478169624844, + "paired_ratio_ci": [0.9510609498940836, 0.9972600333981243], + "candidate_seconds": 0.012706744368188083, + "baseline_seconds": 0.012734603824182636, + "reference_seconds": 0.01001518520726157 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0039016261319569, + "candidate_over_reference": 1.2305082991272875, + "paired_ratio_ci": [0.9917578358429306, 1.0071436074568956], + "candidate_seconds": 0.12937235881552278, + "baseline_seconds": 0.12886955798049235, + "reference_seconds": 0.10513733138352455 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0031201271356596, + "candidate_over_reference": 1.2162737625927116, + "paired_ratio_ci": [0.9908574627646807, 1.0080822153713949], + "candidate_seconds": 0.1314772936249418, + "baseline_seconds": 0.13106834372904683, + "reference_seconds": 0.1080984377601583 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9925941377846605, + "candidate_over_reference": 0.877659994974792, + "paired_ratio_ci": [0.9013696289840912, 1.059063429015765], + "candidate_seconds": 0.0015595888585916587, + "baseline_seconds": 0.0015712251354541098, + "reference_seconds": 0.0017769852420315146 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9836533227658525, + "candidate_over_reference": 0.5770473957350666, + "paired_ratio_ci": [0.9683000468614501, 1.0094132657874206], + "candidate_seconds": 0.001722784807151627, + "baseline_seconds": 0.0017514146165922284, + "reference_seconds": 0.002985516995457666 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.989968460790496, + "candidate_over_reference": 0.9117298075732269, + "paired_ratio_ci": [0.9759756653236039, 1.056594498377637], + "candidate_seconds": 0.011897843985241793, + "baseline_seconds": 0.012018407107375208, + "reference_seconds": 0.013049747728343521 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9822897532516872, + "candidate_over_reference": 0.6807770173067682, + "paired_ratio_ci": [0.9628205495182854, 1.001195243455563], + "candidate_seconds": 0.007759894737752066, + "baseline_seconds": 0.007899802183688041, + "reference_seconds": 0.011398585058660024 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9989501615128866, + "candidate_over_reference": 0.977445401227299, + "paired_ratio_ci": [0.9940766626807227, 1.0037614587681911], + "candidate_seconds": 0.14822245500649192, + "baseline_seconds": 0.14837822818108612, + "reference_seconds": 0.15164269515246684 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9943508510844256, + "candidate_over_reference": 0.8970047873251873, + "paired_ratio_ci": [0.9776186333503422, 1.0183126086278151], + "candidate_seconds": 0.08444531923825187, + "baseline_seconds": 0.08492507362583031, + "reference_seconds": 0.09414143651346898 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0002679908547234, + "candidate_over_reference": 0.8394934022524878, + "paired_ratio_ci": [0.9859943857604776, 1.0613264682944559], + "candidate_seconds": 0.0016555502689221786, + "baseline_seconds": 0.0016551067154588445, + "reference_seconds": 0.0019720825255804117 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9921859497345372, + "candidate_over_reference": 0.6384860067641042, + "paired_ratio_ci": [0.9602805643835963, 1.0035173718023223], + "candidate_seconds": 0.0018994852989202453, + "baseline_seconds": 0.0019144448673441296, + "reference_seconds": 0.0029749834433286672 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.000490009729073, + "candidate_over_reference": 0.5165075050349678, + "paired_ratio_ci": [0.9897811628310391, 1.022641605129947], + "candidate_seconds": 0.014415223528409288, + "baseline_seconds": 0.01440816338817101, + "reference_seconds": 0.02790903014552203 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9797876934360986, + "candidate_over_reference": 0.45374482476615363, + "paired_ratio_ci": [0.9591851476548418, 1.013076542577369], + "candidate_seconds": 0.00859562448957669, + "baseline_seconds": 0.00877294596284628, + "reference_seconds": 0.018943741108246502 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.002378627610879, + "candidate_over_reference": 0.5460572561301636, + "paired_ratio_ci": [0.999492664081629, 1.0117548080861278], + "candidate_seconds": 0.15859735545901849, + "baseline_seconds": 0.15822100660408892, + "reference_seconds": 0.29044088999563383 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.997498206749945, + "candidate_over_reference": 0.5083609113706022, + "paired_ratio_ci": [0.9835643953787064, 1.0202116980135962], + "candidate_seconds": 0.08880528464492056, + "baseline_seconds": 0.08902801433023774, + "reference_seconds": 0.17468944338283368 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9996081831798106, + "candidate_over_reference": 1.3087374272328423, + "paired_ratio_ci": [0.9780756127306253, 1.0106850155564793], + "candidate_seconds": 0.0014598554144391702, + "baseline_seconds": 0.0014604276345510567, + "reference_seconds": 0.0011154685302504472 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.007998419424384, + "candidate_over_reference": 1.350560062610678, + "paired_ratio_ci": [0.9808864973176382, 1.033138793195588], + "candidate_seconds": 0.001625763163680122, + "baseline_seconds": 0.001612862810448167, + "reference_seconds": 0.0012037696128356316 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9944857398855306, + "candidate_over_reference": 0.9450779775775113, + "paired_ratio_ci": [0.9677842837358606, 1.0223593089228395], + "candidate_seconds": 0.0020395174755581786, + "baseline_seconds": 0.0020508262650331573, + "reference_seconds": 0.0021580414780016455 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9910989548195231, + "candidate_over_reference": 1.0860392798451544, + "paired_ratio_ci": [0.9750510164165858, 1.0051397883251847], + "candidate_seconds": 0.0023281806137501484, + "baseline_seconds": 0.002349089969703484, + "reference_seconds": 0.0021437351824715734 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0014873734040066, + "candidate_over_reference": 0.8223457453860542, + "paired_ratio_ci": [0.9796405568491501, 1.0514475183216343], + "candidate_seconds": 0.008672050422146207, + "baseline_seconds": 0.008659171001497833, + "reference_seconds": 0.010545504090952732 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9931291479820257, + "candidate_over_reference": 0.7343587829342365, + "paired_ratio_ci": [0.9811613940266811, 1.0013289465854625], + "candidate_seconds": 0.009453887347176317, + "baseline_seconds": 0.009519293000699864, + "reference_seconds": 0.012873662801991616 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9896237489531957, + "candidate_over_reference": 1.2985263427423084, + "paired_ratio_ci": [0.9420279345938928, 1.001800665476159], + "candidate_seconds": 0.00145278867178907, + "baseline_seconds": 0.0014680212285990517, + "reference_seconds": 0.001118797997367524 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9843216304200801, + "candidate_over_reference": 1.3858311263589447, + "paired_ratio_ci": [0.9538184594527856, 1.006541416157069], + "candidate_seconds": 0.001523694067838646, + "baseline_seconds": 0.0015479636134668475, + "reference_seconds": 0.0010994803326736604 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9919609938979713, + "candidate_over_reference": 1.030673972723171, + "paired_ratio_ci": [0.971767272397931, 1.0145119038433907], + "candidate_seconds": 0.0022819445723490346, + "baseline_seconds": 0.002300437805908067, + "reference_seconds": 0.0022140314325778967 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9965129890635231, + "candidate_over_reference": 1.1965427135513103, + "paired_ratio_ci": [0.9849617286205573, 1.0151552554705126], + "candidate_seconds": 0.0027586768902394744, + "baseline_seconds": 0.002768330087530471, + "reference_seconds": 0.0023055398348896276 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9964676546853249, + "candidate_over_reference": 0.9958681155634528, + "paired_ratio_ci": [0.9852807959607197, 0.9976935668261592], + "candidate_seconds": 0.011443763805021132, + "baseline_seconds": 0.011484330425792862, + "reference_seconds": 0.011491244298494643 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9939458670475899, + "candidate_over_reference": 0.7964708951668381, + "paired_ratio_ci": [0.9865885302279211, 1.0050113086859032], + "candidate_seconds": 0.012156365710931519, + "baseline_seconds": 0.012230410240590572, + "reference_seconds": 0.015262787108353916 + } + ], + "figure_audit": { + "checked_points": 1440, + "verified_missing_points": 480, + "max_error": 1.1102230246251565e-16, + "complete_revisions": 2, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "82cf932c3695848a3e0f6239453fdb224bf8f8ee95a3b9bf3a2889e607a34a0b" + }, + "browser_audit": { + "campaign": "find-listing/native-case/measurements", + "revisions": 2, + "statesChecked": 24, + "errors": [], + "failedResponses": [] + } + }, + "native-case-macos": { + "baseline": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "candidate": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 112, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 56, + "control_p95_factor": 1.0142771243825883, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "bfa904b56f7b87f28b8fc6c74d310edbf584b592d0cc4f099854c37e5b0ddd06" + }, + "builds": [ + { + "source": { + "revision": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "tree": "aa6af8508ed4fc63d352e62bf0222c028acfc884", + "clean": true + }, + "sha256": "923d11cd6894683eec7f97e12e0fff0e5733b2d4e7689a261135ac1bb19efe61", + "bytes": 8279016, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/darwin_arm64-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 15.997534583322704, + "completed_at": "2026-11-07T19:18:26.091383+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "tree": "334ec6a7c02868e97a6cf06077da7b2158801b10", + "clean": true + }, + "sha256": "2662daa1f7a8604b339643b1a25bbc9c05c053983296e69b2880d61485dc5c4b", + "bytes": 8278344, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/Users/marcus/.cache/bazel-disk", + "--jobs=6", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/darwin_arm64-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 23.111399083398283, + "completed_at": "2026-11-07T18:49:07.236573+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "native-case-macos", + "contract_sha256": "bfa904b56f7b87f28b8fc6c74d310edbf584b592d0cc4f099854c37e5b0ddd06", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 112, + "validated_invocations": 9408, + "numeric_fields": 560, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9892690727544319, + "candidate_over_reference": 1.3408976338304595, + "paired_ratio_ci": [0.9788372132585066, 1.0026632886156346], + "candidate_seconds": 0.010255799584445498, + "baseline_seconds": 0.01036704761818761, + "reference_seconds": 0.007648458260865439 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9934133414017446, + "candidate_over_reference": 1.435144393301947, + "paired_ratio_ci": [0.9718650688358691, 1.0246965611001217], + "candidate_seconds": 0.008785968335966269, + "baseline_seconds": 0.008844222208218915, + "reference_seconds": 0.00612201000608149 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9992584350002292, + "candidate_over_reference": 1.355479401076619, + "paired_ratio_ci": [0.9694236273339034, 1.011296710289485], + "candidate_seconds": 0.011183874992032846, + "baseline_seconds": 0.011192174717074349, + "reference_seconds": 0.008250863113928409 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0005994938311937, + "candidate_over_reference": 1.3473529992251156, + "paired_ratio_ci": [0.9736742818953743, 1.0586181131417338], + "candidate_seconds": 0.011551311638738428, + "baseline_seconds": 0.011544390847640378, + "reference_seconds": 0.008573337236330622 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0078441144293793, + "candidate_over_reference": 0.8683277956329041, + "paired_ratio_ci": [0.999781212944831, 1.0148834580497217], + "candidate_seconds": 0.031622914863484244, + "baseline_seconds": 0.03137679171881506, + "reference_seconds": 0.036418176433514984 + }, + { + "name": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0118575708288546, + "candidate_over_reference": 0.9074411620710593, + "paired_ratio_ci": [0.9961888359214712, 1.0150915252495425], + "candidate_seconds": 0.03339738895495733, + "baseline_seconds": 0.03300601776157107, + "reference_seconds": 0.03680391671756903 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.003752958780097, + "candidate_over_reference": 1.2898448694031233, + "paired_ratio_ci": [0.9826820894639009, 1.0109108027713642], + "candidate_seconds": 0.01136053375722397, + "baseline_seconds": 0.011318057553753966, + "reference_seconds": 0.008807674493818056 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.0078710879944472, + "candidate_over_reference": 1.3836919567516683, + "paired_ratio_ci": [0.9981709812119397, 1.0630018842707953], + "candidate_seconds": 0.009321353486960842, + "baseline_seconds": 0.00924855727879774, + "reference_seconds": 0.006736581391167073 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9965539381138815, + "candidate_over_reference": 1.3161675374752084, + "paired_ratio_ci": [0.9910374578866977, 1.019705306763454], + "candidate_seconds": 0.0125761271143953, + "baseline_seconds": 0.012619615088970889, + "reference_seconds": 0.009555111151366006 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0002136933050108, + "candidate_over_reference": 1.3310980199980351, + "paired_ratio_ci": [0.9751331884127611, 1.0059705225773772], + "candidate_seconds": 0.01201693651576837, + "baseline_seconds": 0.012014369125522319, + "reference_seconds": 0.009027837420858088 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9998089207585121, + "candidate_over_reference": 1.2399200097711849, + "paired_ratio_ci": [0.9956003387749524, 1.0098310148228016], + "candidate_seconds": 0.03411527971426646, + "baseline_seconds": 0.03412179968186787, + "reference_seconds": 0.027514097236451648 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0059176113921888, + "candidate_over_reference": 1.2420043760907695, + "paired_ratio_ci": [1.001619641825974, 1.0285916032065434], + "candidate_seconds": 0.033724898738520484, + "baseline_seconds": 0.03352650192876657, + "reference_seconds": 0.027153607014389264 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9818002204878141, + "candidate_over_reference": 1.369672523524067, + "paired_ratio_ci": [0.9382567045726946, 0.995893114408975], + "candidate_seconds": 0.00941856928347122, + "baseline_seconds": 0.0095931627299814, + "reference_seconds": 0.006876511809726556 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9958225957367898, + "candidate_over_reference": 1.4015834447985793, + "paired_ratio_ci": [0.9733471872794739, 1.0340485326019748], + "candidate_seconds": 0.009754289606852191, + "baseline_seconds": 0.009795208151141802, + "reference_seconds": 0.006959478326496624 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.5703377138976332, + "candidate_over_reference": 1.2004382812560228, + "paired_ratio_ci": [0.5570907996336895, 0.5788085611221717], + "candidate_seconds": 0.013148579258649122, + "baseline_seconds": 0.023054023849822226, + "reference_seconds": 0.010953148915654137 + }, + { + "name": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.5951416824484974, + "candidate_over_reference": 1.206096595279421, + "paired_ratio_ci": [0.5573208714225305, 0.6003159526574392], + "candidate_seconds": 0.012044712413279783, + "baseline_seconds": 0.02023839493769975, + "reference_seconds": 0.009986523849268755 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.3121845725013381, + "candidate_over_reference": 0.7365191411851048, + "paired_ratio_ci": [0.3082837371682318, 0.3134975466351082], + "candidate_seconds": 0.03555103954637334, + "baseline_seconds": 0.11387827163118691, + "reference_seconds": 0.04826899609040646 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.2983453998196883, + "candidate_over_reference": 0.7376738655338549, + "paired_ratio_ci": [0.29308057416636524, 0.33368793916630013], + "candidate_seconds": 0.0348109147023587, + "baseline_seconds": 0.11667991101387001, + "reference_seconds": 0.04719011521055585 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9782244762286025, + "candidate_over_reference": 1.367151302619852, + "paired_ratio_ci": [0.9698810171612313, 0.9927414910983878], + "candidate_seconds": 0.009551781540115675, + "baseline_seconds": 0.009764406608328932, + "reference_seconds": 0.006986630903113456 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9842625248756278, + "candidate_over_reference": 1.2677672032665361, + "paired_ratio_ci": [0.9683828988617824, 0.9950841854801463], + "candidate_seconds": 0.011469001926126935, + "baseline_seconds": 0.011652380981970401, + "reference_seconds": 0.009046615101397038 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.649851923192904, + "candidate_over_reference": 1.0967258396808408, + "paired_ratio_ci": [0.6243526009570054, 0.6595854042676447], + "candidate_seconds": 0.014357462259275573, + "baseline_seconds": 0.022093436592036768, + "reference_seconds": 0.01309120451055822 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.4009199745870894, + "candidate_over_reference": 1.1033207975462247, + "paired_ratio_ci": [0.39634648159219205, 0.40413651945076856], + "candidate_seconds": 0.013323535654871236, + "baseline_seconds": 0.033232406713068485, + "reference_seconds": 0.012075849276568209 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.287739860489724, + "candidate_over_reference": 0.768717968823154, + "paired_ratio_ci": [0.2845794089747451, 0.2889692756980978], + "candidate_seconds": 0.03521151397199858, + "baseline_seconds": 0.12237273595694985, + "reference_seconds": 0.0458055039690364 + }, + { + "name": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.2602660456497225, + "candidate_over_reference": 0.7754979652661564, + "paired_ratio_ci": [0.2570860150660633, 0.26107779619024835], + "candidate_seconds": 0.03640504571653548, + "baseline_seconds": 0.1398762778512069, + "reference_seconds": 0.046944089278223966 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9935022840807046, + "candidate_over_reference": 1.2812467409408674, + "paired_ratio_ci": [0.8848901349574513, 1.1224210485842192], + "candidate_seconds": 0.010971503864441599, + "baseline_seconds": 0.01104325982963755, + "reference_seconds": 0.008563146749067874 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9959184715313603, + "candidate_over_reference": 1.2808189466562936, + "paired_ratio_ci": [0.9751532534315435, 1.004335011169948], + "candidate_seconds": 0.010172769737740358, + "baseline_seconds": 0.010214460348444325, + "reference_seconds": 0.007942394796936285 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.008057231990772, + "candidate_over_reference": 0.7465196507167493, + "paired_ratio_ci": [0.9969876384997695, 1.0235373453272418], + "candidate_seconds": 0.0206926048156761, + "baseline_seconds": 0.020527212304018792, + "reference_seconds": 0.027718767745509035 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9968663943022414, + "candidate_over_reference": 0.7528252814850962, + "paired_ratio_ci": [0.9905632349039353, 1.0022222953525277], + "candidate_seconds": 0.02217247026662032, + "baseline_seconds": 0.022242168452413308, + "reference_seconds": 0.029452345467039516 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0080832023514734, + "candidate_over_reference": 0.5841557206294752, + "paired_ratio_ci": [0.9989048234684998, 1.0143742188799687], + "candidate_seconds": 0.1299493551875154, + "baseline_seconds": 0.1289073708245442, + "reference_seconds": 0.22245670220858993 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9967048262326345, + "candidate_over_reference": 0.5796744081681736, + "paired_ratio_ci": [0.9728809233274816, 1.0048578420955965], + "candidate_seconds": 0.12652001583150455, + "baseline_seconds": 0.12693829958637556, + "reference_seconds": 0.21826048217536437 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.996889783231538, + "candidate_over_reference": 1.2921763695044248, + "paired_ratio_ci": [0.9867813788594653, 1.0150996302178434], + "candidate_seconds": 0.009735867026306334, + "baseline_seconds": 0.009766242156426111, + "reference_seconds": 0.007534472271800041 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9949191363748635, + "candidate_over_reference": 1.2675789623614713, + "paired_ratio_ci": [0.9853223457751482, 1.0053131050890924], + "candidate_seconds": 0.010044539702080545, + "baseline_seconds": 0.010095835264239992, + "reference_seconds": 0.007924192496353672 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9957358913179293, + "candidate_over_reference": 0.8528020301224545, + "paired_ratio_ci": [0.9902532706460236, 1.0020570100218116], + "candidate_seconds": 0.025622750144629253, + "baseline_seconds": 0.025732476219889663, + "reference_seconds": 0.030045367200814542 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0063886211759747, + "candidate_over_reference": 0.8693071083968658, + "paired_ratio_ci": [0.992909805211605, 1.0153934010677304], + "candidate_seconds": 0.026620698383166677, + "baseline_seconds": 0.026451708438495796, + "reference_seconds": 0.030622892791316622 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0035473819597611, + "candidate_over_reference": 0.7633446326815878, + "paired_ratio_ci": [0.9888048700417987, 1.0043032049962417], + "candidate_seconds": 0.16090226013745582, + "baseline_seconds": 0.16033349598624877, + "reference_seconds": 0.21078586689240875 + }, + { + "name": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0041962064981518, + "candidate_over_reference": 0.7559682935499222, + "paired_ratio_ci": [0.9921659679935321, 1.012224261062346], + "candidate_seconds": 0.1617369009625344, + "baseline_seconds": 0.16106105551478408, + "reference_seconds": 0.21394667255559138 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0024148969518025, + "candidate_over_reference": 1.1546654515965435, + "paired_ratio_ci": [0.9913971914600226, 1.0202486735461596], + "candidate_seconds": 0.009141200310772373, + "baseline_seconds": 0.009119178434567792, + "reference_seconds": 0.007916752249002457 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.993500843093024, + "candidate_over_reference": 1.0490200436552535, + "paired_ratio_ci": [0.9830810247751612, 1.0363308633392752], + "candidate_seconds": 0.010070023925176688, + "baseline_seconds": 0.010135898721360025, + "reference_seconds": 0.009599458071447554 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0014729094083576, + "candidate_over_reference": 0.835043692970481, + "paired_ratio_ci": [0.9816337300448593, 1.013637852603524], + "candidate_seconds": 0.0785019722811523, + "baseline_seconds": 0.07838651604418244, + "reference_seconds": 0.09400941883879048 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0027735443930457, + "candidate_over_reference": 0.8271668690841578, + "paired_ratio_ci": [0.9849056041557585, 1.0313786764695636], + "candidate_seconds": 0.05099639487231061, + "baseline_seconds": 0.050855345314457304, + "reference_seconds": 0.06165188280422063 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9925201574810496, + "candidate_over_reference": 1.0746005431639347, + "paired_ratio_ci": [0.9912404038314349, 1.0433648091143144], + "candidate_seconds": 0.010983978309446857, + "baseline_seconds": 0.01106675590078036, + "reference_seconds": 0.01022145240789368 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.0103162111361281, + "candidate_over_reference": 0.9766593605704215, + "paired_ratio_ci": [0.9906645545395719, 1.064737396162902], + "candidate_seconds": 0.01213501003526506, + "baseline_seconds": 0.01201110098156191, + "reference_seconds": 0.012425017897926625 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9997855384768426, + "candidate_over_reference": 0.6300248476524817, + "paired_ratio_ci": [0.9907249454235724, 1.0092248188168729], + "candidate_seconds": 0.11567676980935392, + "baseline_seconds": 0.11570158334715026, + "reference_seconds": 0.1836066787530269 + }, + { + "name": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0020767270076123, + "candidate_over_reference": 0.8552880776271502, + "paired_ratio_ci": [0.9942754035405688, 1.011846070294304], + "candidate_seconds": 0.10147712694569713, + "baseline_seconds": 0.10126682339857022, + "reference_seconds": 0.11864672219824224 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0096446038372873, + "candidate_over_reference": 1.3475201561972852, + "paired_ratio_ci": [0.9929924480689847, 1.0457813168530807], + "candidate_seconds": 0.010039982031143847, + "baseline_seconds": 0.00994407536373252, + "reference_seconds": 0.007450710095110394 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9847938772177406, + "candidate_over_reference": 1.3214914429192477, + "paired_ratio_ci": [0.9686201864975392, 1.0070552622073055], + "candidate_seconds": 0.009953460256968225, + "baseline_seconds": 0.01010715083352157, + "reference_seconds": 0.007531989942349139 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9957422876889603, + "candidate_over_reference": 1.2626272647960757, + "paired_ratio_ci": [0.9877041000163848, 1.0077296483309668], + "candidate_seconds": 0.011102684596109958, + "baseline_seconds": 0.011150158764350982, + "reference_seconds": 0.008793319220699015 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9934338594186296, + "candidate_over_reference": 1.2954984391964617, + "paired_ratio_ci": [0.9749501475656307, 1.0032794104961897], + "candidate_seconds": 0.01097558323471319, + "baseline_seconds": 0.011048126788366409, + "reference_seconds": 0.008472092981849397 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9988051663728992, + "candidate_over_reference": 1.0824438707528596, + "paired_ratio_ci": [0.9893022762389435, 1.0031057206174099], + "candidate_seconds": 0.01764263687211843, + "baseline_seconds": 0.01766374210516612, + "reference_seconds": 0.01629889304084437 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0011374830346766, + "candidate_over_reference": 1.0829670081034697, + "paired_ratio_ci": [0.9898934497097063, 1.0141237984290559], + "candidate_seconds": 0.01939098417226757, + "baseline_seconds": 0.019368952317606835, + "reference_seconds": 0.017905424659450848 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9953512338282655, + "candidate_over_reference": 1.297241022906022, + "paired_ratio_ci": [0.9725656247419622, 1.0018130845782545], + "candidate_seconds": 0.01047696629982619, + "baseline_seconds": 0.010525898741824287, + "reference_seconds": 0.008076345193244162 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.0017559126885318, + "candidate_over_reference": 1.395509664395703, + "paired_ratio_ci": [0.9973330287280988, 1.040345625696053], + "candidate_seconds": 0.008691037650264445, + "baseline_seconds": 0.008675803696470601, + "reference_seconds": 0.006227859162858554 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9971396149951942, + "candidate_over_reference": 1.2683878796284662, + "paired_ratio_ci": [0.9815908874567292, 1.0209347814956726], + "candidate_seconds": 0.011299184523522854, + "baseline_seconds": 0.011331597254389808, + "reference_seconds": 0.008908303764959177 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9999860555696845, + "candidate_over_reference": 1.3504464632232307, + "paired_ratio_ci": [0.9737553754714465, 1.010426663385441], + "candidate_seconds": 0.010520575656777336, + "baseline_seconds": 0.010520722362257186, + "reference_seconds": 0.007790442600491501 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9946883781538648, + "candidate_over_reference": 1.1743227128479823, + "paired_ratio_ci": [0.9705529232133581, 1.010166355885622], + "candidate_seconds": 0.020748674603445188, + "baseline_seconds": 0.020859472231850737, + "reference_seconds": 0.017668630927801132 + }, + { + "name": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0148322780946621, + "candidate_over_reference": 1.1763630520308923, + "paired_ratio_ci": [0.9824522346709361, 1.0248933252510322], + "candidate_seconds": 0.021253404828409355, + "baseline_seconds": 0.020942775754346735, + "reference_seconds": 0.018067045536424433 + } + ], + "selection": { + "selection": "Every original case except 100,000-file content regex, which explicitly disables native case. All native cases and all archive sizes remain; content regex at 100 and 10,000 files remains as a regression control. Linux retains the complete suite.", + "selected_cases": 56, + "fixture": "/Volumes/XFF_FIND_20261107/fixtures" + }, + "figure_audit": { + "checked_points": 1344, + "verified_missing_points": 576, + "max_error": 1.1102230246251565e-16, + "complete_revisions": 2, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "bfa904b56f7b87f28b8fc6c74d310edbf584b592d0cc4f099854c37e5b0ddd06" + }, + "browser_audit": { + "campaign": "find-listing/native-case-macos/measurements", + "revisions": 2, + "statesChecked": 24, + "errors": [], + "failedResponses": [] + } + }, + "native-case-repeat": { + "baseline": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "candidate": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "summary": { + "recipe": "extended-production-v1", + "state": "complete", + "cells": 14, + "complete_revisions": 2, + "expected_revisions": 2, + "identical_binary_control_cells": 7, + "control_p95_factor": 1.0107473720339801, + "interval": "95% paired-round bootstrap geometric ratio; within-cell variability only", + "task_summary": "Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.", + "current_reference_summary": "Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.", + "contract_sha256": "d5f1c0a7211cb8465fdc9cdae99118a4e83edab7d36816263355f8a8b5159f8e" + }, + "builds": [ + { + "source": { + "revision": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "tree": "aa6af8508ed4fc63d352e62bf0222c028acfc884", + "clean": true + }, + "sha256": "b86ee4f2607f60db513dac1829b66867ef7a928edc3b1fdbc777ac4a3efb1cf4", + "bytes": 18477056, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 13.374229129054584, + "completed_at": "2026-11-07T19:18:03.263448+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + }, + { + "source": { + "revision": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "tree": "334ec6a7c02868e97a6cf06077da7b2158801b10", + "clean": true + }, + "sha256": "c622f2352528be0de99eb41f87fc9e4b2e69b732745a0f4583c71156471f54cc", + "bytes": 18472096, + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "build", + "//xff/cli:xff_full", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu" + ], + "query": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "cquery", + "config(//xff/cli:xff_full, target)", + "--config=clang_release", + "--config=xff_full", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--jobs=6", + "--action_env=LD_LIBRARY_PATH=/home/marcus/Documents/xff-chart-campaign-20261107/compat/usr/lib/x86_64-linux-gnu", + "--output=starlark", + "--starlark:expr=target.files_to_run.executable.path" + ], + "artifact": "bazel-out/k8-opt/bin/xff/cli/xff_full", + "elapsed_seconds": 0.7000186709919944, + "completed_at": "2026-11-07T18:54:52.779121+00:00", + "configuration": { + ".bazelrc": "c9ad460455c535982a7723db0f17a17fb73f8f2c52c34d2a8decc53d45025211", + ".bazelversion": "1b9487d55bea47fea50d226cc9c53bc548877ad2a318bac8fbc8b320f429e5c5", + "MODULE.bazel": "5ca469c9517d86aff3ed066c97e722f83d54435f071902c6f697418974be65ef", + "MODULE.bazel.lock": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "bazelmod/llvm.MODULE.bazel": "84be80cd60001d81dda163bd1777b00097cdfd263b757ae6e8982754ca25d381" + } + } + ], + "audit": { + "stage": "native-case-repeat", + "contract_sha256": "d5f1c0a7211cb8465fdc9cdae99118a4e83edab7d36816263355f8a8b5159f8e", + "audit_script_sha256": "a61dca93edbea8a67c1c9947c40cc42efb8ab43330ce94770448055e2a09c2c1", + "cells": 14, + "validated_invocations": 1176, + "numeric_fields": 70, + "build_identities": 2 + }, + "rows": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 1.0025483842523795, + "candidate_over_reference": 1.4486363088674992, + "paired_ratio_ci": [0.9859297251129631, 1.0162808171934528], + "candidate_seconds": 0.0013138522183345188, + "baseline_seconds": 0.0013105125288434682, + "reference_seconds": 0.000906957950930865 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9994180674603791, + "candidate_over_reference": 1.1656040691285514, + "paired_ratio_ci": [0.9950151351254403, 1.0014934249485385], + "candidate_seconds": 0.0579982499004386, + "baseline_seconds": 0.05803202062157825, + "reference_seconds": 0.04975810520617025 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0035081057510964, + "candidate_over_reference": 1.0199290255217652, + "paired_ratio_ci": [0.9967608363516012, 1.0059054211976997], + "candidate_seconds": 0.04199765387013377, + "baseline_seconds": 0.04185083670918608, + "reference_seconds": 0.04117703567525106 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.990236812178842, + "candidate_over_reference": 1.1771700100143374, + "paired_ratio_ci": [0.9572925397759563, 1.000024004671126], + "candidate_seconds": 0.004956772262674002, + "baseline_seconds": 0.005005643298361628, + "reference_seconds": 0.004210753094715376 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9981919875020033, + "candidate_over_reference": 1.0363528547486722, + "paired_ratio_ci": [0.9953239543491433, 1.0001322515595024], + "candidate_seconds": 0.10810239353061964, + "baseline_seconds": 0.10829819802616146, + "reference_seconds": 0.10431041226478382 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9975501236315676, + "candidate_over_reference": 0.9028675616869701, + "paired_ratio_ci": [0.9937284461519778, 1.0222622264050192], + "candidate_seconds": 0.011544365518992501, + "baseline_seconds": 0.011572717245490778, + "reference_seconds": 0.012786333244072185 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 1.0154966895882171, + "candidate_over_reference": 0.9317616287998652, + "paired_ratio_ci": [1.0018565712950747, 1.042639916378481], + "candidate_seconds": 0.0020215319569355677, + "baseline_seconds": 0.0019906829610200866, + "reference_seconds": 0.002169580603506239 + } + ], + "selection": { + "reason": "Repeat the one Linux native-case cell whose within-cell interval excluded parity in the slower direction, alongside predeclared listing, metadata, content and archive controls.", + "cases": [ + { + "name": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1 + }, + { + "name": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1 + }, + { + "name": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1 + }, + { + "name": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1 + }, + { + "name": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1 + }, + { + "name": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1 + }, + { + "name": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1 + } + ], + "command": [ + "python3.13", + "/home/marcus/Documents/xff-chart-campaign-20261107/benchmark_extended_history.py", + "--root", + "/home/marcus/Documents/xff-chart-campaign-20261107/find-listing/native-case-repeat/measurements", + "--build-root", + "/home/marcus/Documents/xff-chart-campaign-20261107/find-listing/native-case/build", + "--revisions", + "/home/marcus/Documents/xff-chart-campaign-20261107/find-listing/native-case-repeat/revisions.json", + "--cases", + "/home/marcus/Documents/xff-chart-campaign-20261107/find-listing/native-case-repeat/cases.json", + "--fixture", + "/dev/shm/xff-find-native-case-repeat-20261107", + "--resource-launcher", + "/home/marcus/Documents/xff-chart-campaign-20261107/benchmark-resource-launcher", + "--repetitions", + "27", + "--keep", + "21" + ] + } + } + }, + "instructions": { + "files-exact/broad/100/1": { + "xff": 1727276, + "anchor": 1904767, + "find": 566412 + }, + "files-exact/broad/100000/1": { + "xff": 218843739, + "anchor": 233207036, + "find": 106212516 + }, + "files-exact/deep/100000/1": { + "xff": 220817669, + "anchor": 245730492, + "find": 110644735 + } + }, + "four_change_candidate": "5bcfcdac9399ddc0426df5d88c2b260fcfa378f0", + "comparison_note": "Combined and macos compare the first four changes with baseline. Native-case stages compare the fifth change with four_change_candidate; do not compound separate-run percentages.", + "validation": { + "cells": 726, + "validated_invocations": 60984, + "additional_linux_tests": { + "command": [ + "bazel", + "--nosystem_rc", + "--nohome_rc", + "test", + "//xff/engine:run_test", + "--config=clang_opt", + "--jobs=6", + "--disk_cache=/home/marcus/.cache/bazel-disk", + "--test_output=errors" + ], + "exit_code": 0, + "source": "3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b", + "patch": "/home/marcus/Documents/xff-chart-campaign-20261107/find-listing/native-case/extra-tests.patch" + }, + "additional_macos_tests": { + "command": [ + "bazel", + "test", + "//xff/engine:run_test", + "--config=clang_opt" + ], + "returncode": 0, + "seconds": 55.106588709168136 + }, + "extra_tests_patch_sha256": "ed86ccbed6adc377ad8e98d62038cb148ddf55e19598d3f6da68df09520450ec" + } +} diff --git a/docs/benchmarks/find-listing-optimization-20261107.md b/docs/benchmarks/find-listing-optimization-20261107.md new file mode 100644 index 00000000000..aa33be10764 --- /dev/null +++ b/docs/benchmarks/find-listing-optimization-20261107.md @@ -0,0 +1,314 @@ +# Basic-operation optimization qualification (2026-11-07) + +## Objective + +Reduce the production binary's startup and per-entry work for ordinary listing, name filtering, +and metadata output. The reference is the traditional tool performing the same task, with every +output checked against an independent fixture oracle. A small improvement is worth retaining +when the measurements and instruction counts support it; the chart's visual scale is not an +acceptance threshold. + +The starting point already contains the adopted [lazy content snapshot](lazy-content-state-20261107.md). +Its retained production source is `90abd2b3ef63b35833e8f9d96745475c6b9f182a`. The source for the four-change +comparison is `5bcfcdac9399ddc0426df5d88c2b260fcfa378f0`. The intervening commits contain +four independent changes, measured incrementally on Linux and together against the original +baseline on both Linux and macOS. None of these commits is presented as a merged PR. +A fifth change removes unnecessary native-case metadata lookups, measured separately against +the four-change binary. Its Mac name-filtering results and Linux controls are included below. + +## Three-core priority and coverage + +Three cores are the primary optimization target. One core diagnoses serial overhead and parallel +speedup; ten cores expose contention and filesystem saturation. Future qualification should use +all three settings. This completed campaign measured one and three only: it makes no ten-core +claim, and its frozen measurements are not relabeled or extrapolated. + +At 100,000 files, the three-core results equally weighting broad/deep shapes are: + +| Platform and task | Comparison | Elapsed change | Candidate/GNU find | +| :----------------- | :------------------------------------------- | -------------: | -----------------: | +| Linux listing | First four changes versus adopted baseline | -2.38% | 1.1396 | +| Mac listing | First four changes versus adopted baseline | -5.24% | 1.0255 | +| Mac name filtering | Native-case change versus four-change binary | -72.13% | 0.7563 | +| Mac listing | Native-case change versus four-change binary | +0.89% | 1.0616 | + +The large Mac name-filtering gain is 24.37% less elapsed time than GNU find. Ordinary listing +still has a gap, and the native-case change does not improve it. The separate comparisons must +not be compounded into a claimed total gain. On Mac, three means requested XFF workers, not +three pinned physical cores. + +## Implemented changes + +1. **Archive suffix lookup:** build the lookup on first use, and borrow each reader's format + records while doing so. Registering several extras previously rebuilt the lookup repeatedly + and copied all their descriptive strings. Registration still precedes concurrent registry + reads; the first concurrent lookup publishes the immutable set under a mutex. +2. **Ordinary expression results:** carry two booleans through the prepared recursive evaluator + when neither fuzzy scoring nor deferred evaluation is active. The general result path remains + for those capabilities. Both paths share predicate metadata checks, effects, invalidation, + dry-run safety and error handling. This does not rewrite or recognize a benchmark command. +3. **Explicit path output:** reuse the coordinator's record storage for `-print` and `-print0`, + including mixed terminators, instead of allocating a temporary path string for each output. + Retention remains bounded; sinks consume each complete borrowed record before returning. + Worker threads do not share the buffer. +4. **Directory prefix reuse:** retain the parent prefix while iterating a directory's name-only + children, truncating the previous basename before appending the next. The metadata-bearing + path already used this pattern. Nested directory visits own separate scratch storage. + +The production command remains `bazel build //xff/cli:xff_full --config=clang_release +--config=xff_full`. Every configured executable is queried, immediately copied and hashed; +actual link actions retain the ThinLTO evidence. No test executable or non-LTO CLI substitutes +for the production binary. + +## Measurement contract + +The Linux fixture is on `/dev/shm` tmpfs. macOS uses an owned 2 GiB case-sensitive HFS+ RAM disk; +its device, volume UUID and live `ram://` image are checked before collection. Neither fixture is +on an SSD. HFS+ on a RAM disk and Linux tmpfs have different kernel behavior, so their absolute +timings are not pooled. + +The frozen extended workloads are file listing, native-case name filtering, metadata and UTC date +formatting, content regex, and TAR-member filtering. Broad and deep shapes span 100, 10,000 and +100,000 native files, or 100, 1,000 and 10,000 archive members. The incremental Linux comparisons +use all 30 one-CPU cases. Combined comparisons use all 60 cases, including one and three workers. +Linux restricts the process family to one or three allowed guest cores. macOS does not claim CPU +affinity: the worker setting is explicit, and the OS schedules all participants normally. + +Every case contains a candidate block and an identical-baseline control block. Each block rotates +its XFF binary, the fixed baseline and the traditional tool through one discarded warm-up round +and 27 measured rounds. The chart retains the fastest 21 samples per participant. Paired bootstrap +intervals use all measured rounds and describe within-cell variability; they are not independent +host confidence intervals, multiple-comparison corrections, or intervals for the fastest-sample +estimator. The direct combined comparison establishes the total effect; incremental percentages +must not be added together. + +GNU find, ripgrep and GNU tar are retained by path, version and executable hash on each platform. +The Mac uses Homebrew GNU find and GNU tar for these same recipes; this is not a BSD-find claim. +All invocations check exact record multiplicity and content against the fixture oracle. Fixture +contents/metadata and executable hashes are checked again after collection. Raw samples and +failed attempts are preserved. Diagnostic `perf` runs are separate and never enter the chart. + +## Combined Linux results + +The complete combined comparison contains 120 cells and 10,080 validated invocations. Its 60 +identical-baseline control cells have a 95th percentile multiplicative distance from parity of +1.0161. Within-cell paired intervals exclude parity in the faster direction for 42 candidate +cases and in the slower direction for none. The complete results, including inconclusive cells, +are in [the result data](find-listing-optimization-20261107.json). + +The table equally weights both shapes and CPU allowances at each size. Negative elapsed change +means the candidate is faster; a candidate/reference ratio below one means XFF beats that tool. + +| Task | Files or members | Elapsed change | Candidate/reference | +| :-------------------- | ---------------: | -------------: | ------------------: | +| File listing | 100 | -1.92% | 1.4245 | +| File listing | 10,000 | -2.29% | 1.3548 | +| File listing | 100,000 | -2.23% | 1.1341 | +| Name filtering | 100,000 | -4.30% | 1.0421 | +| Metadata and UTC date | 100,000 | -2.11% | 1.1238 | +| Content regex | 100,000 | -1.13% | 0.7036 | +| TAR member filtering | 10,000 | -2.54% | 0.8377 | + +For one allowed CPU, 100,000-file broad listing improves by 1.46% and remains 9.35% slower than +find; the deep listing improves by 2.68% and remains 16.47% slower. The individual incremental +populations suggest larger accumulated gains than this direct comparison. The retained candidate +and baseline hashes match across the stages. The combined measurement takes precedence; summing +incremental percentages would overstate the supported improvement. + +## Four-change macOS results + +The complete Mac comparison also contains 120 cells and 10,080 validated invocations. Its +identical-baseline controls have a 95th percentile factor of 1.0248. Sixteen candidate cells have +within-cell intervals wholly below parity; one lies wholly above parity (broad 100-member TAR +with one worker, +3.00%, interval 1.00004-1.06040). This single interval is not adjusted for the +60 comparisons. All cells, including that counterexample, remain in the result data. + +| Task | Files or members | Elapsed change | Candidate/reference | +| :------------------------- | ---------------: | -------------: | ------------------: | +| File listing | 100 | -0.16% | 1.3450 | +| File listing | 10,000 | -2.15% | 1.3362 | +| File listing | 100,000 | -6.12% | 1.0225 | +| Native-case name filtering | 100,000 | -1.59% | 2.6180 | +| Metadata and UTC date | 100,000 | -2.05% | 0.6680 | +| Content regex | 100,000 | +0.82% | 0.8118 | +| TAR member filtering | 10,000 | -1.12% | 1.1295 | + +These equally weighted shape/worker summaries expose a distinct Mac problem: native-case name +filtering remains 2.62 times find's elapsed time, even while metadata/date output is faster. +The run driver eagerly requests full metadata for every entry when filesystem case sensitivity +is not uniform. On macOS this is done to obtain the device for the existing case-rule cache, +even when the pattern would have the same result on either kind of filesystem. + +## Follow-up: resolve native case only when it changes a result + +Source `3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b` removes that eager metadata requirement. +When native case is unknown, glob matching evaluates exact and folded truth values. Equal +answers need no filesystem observation. Different answers call a per-entry resolver, which loads +metadata and uses the existing device cache. The resolver does not assume anything about parent +directories, roots or mount boundaries. Explicit folding and backend-wide guarantees retain their +existing direct path. Fuzzy matching resolves native case when reached; deferred replay keeps +its complete-metadata path. + +Both truth values must be checked: `[!A]` against `a` can match exactly and fail under folding. +Required metadata failures remain unknown and cannot become matches through negation. Regression +fixtures count metadata calls and case probes, reject unwanted metadata accesses, test explicit +folding, and check shared resolution across multiple reached predicates. The existing glob +matrix checks direct, prepared and iterative evaluation against native `fnmatch` under both case +rules, with exact resolver call counts. + +The follow-up compares against the retained four-change binary, not the original baseline. +Linux runs the complete 60 cases. macOS predeclares 56 cases: all listing, native name, metadata +and archive cases, plus the 100/10,000-file content cases. Only the four 100,000-file content +regex cases are omitted; that recipe explicitly disables native case. The full four-change +population above retains those cases. The same RAM fixtures and measurement protocol are used. +The effect is expected to depend on how often exact and folded pattern answers agree; it is not +a promise that every native-case search can avoid metadata. + +### Completed follow-up results + +The Mac follow-up contains 112 cells and 9,408 validated invocations. Its identical-baseline +control factor is 1.0143 at the 95th percentile. Eleven candidate intervals exclude parity in the +faster direction. One listing interval excludes it in the slower direction: deep 100,000 files, +three workers, +0.59% (1.00162-1.02859). The following summaries equally weight shapes and workers. + +| Task | Files | Elapsed change versus four-change XFF | Candidate/GNU find | +| :------------------------- | ------: | ------------------------------------: | -----------------: | +| Native-case name filtering | 100 | -1.50% | 1.3506 | +| Native-case name filtering | 10,000 | -45.47% | 1.1505 | +| Native-case name filtering | 100,000 | -71.10% | 0.7544 | +| File listing | 100,000 | +0.64% | 1.0495 | +| Metadata and UTC date | 100,000 | +0.31% | 0.6649 | + +All four 100,000-file name-filtering cells beat GNU find: elapsed time is 22.45-26.35% lower. +The improvement over the previous XFF binary is 68.78-73.97%. This is a production-binary result +on the retained RAM fixture; smaller directories still expose startup costs. Listing and +metadata/date already avoid this particular case-resolution cost, so they do not show the same +improvement. The other tasks and all counterexamples remain in the result data. + +The complete Linux follow-up has 120 cells, 10,080 validated invocations and a control factor of +1.0121. Five candidate intervals exclude parity in the faster direction. One excludes it in the +slower direction: deep 10,000-file name filtering on one CPU, +0.69% (1.00278-1.02234). +Linux supplies a uniform case rule, so the large Mac improvement is not expected there. +At 100,000 files, Linux listing changes by -0.13%, native name filtering by +0.13% and +metadata/date by +0.29%; these differences do not establish a useful improvement or regression. + +A separately declared seven-case Linux repeat retained the same binaries, 27 rounds and seven +identical-baseline controls, adding 14 cells and 1,176 validated invocations. The suspected name +regression did not repeat: -0.98%, interval 0.95729-1.00002. Another repeat cell, broad 1,000-member +TAR on one CPU, was +1.55% with interval 1.00186-1.04264; the full population had -0.55% for that +cell with an interval crossing parity. Both populations are retained. These small, inconsistent +effects are not evidence that the change improves every Linux workload. + +The fifth change is retained for the large, consistent Mac name-filtering gain and its tested +lazy-metadata behavior. It does not close the Linux listing gap. Do not multiply its separately +measured percentage by the four-change result to claim a total improvement. + +## Instruction counts and remaining targets + +Eleven `perf stat` repetitions per executable count userspace instructions on the same Linux +fixtures. Profiling writes to `/dev/null`, after independent output validation, and is excluded +from the chart's output-capture timings. These counters show reduced executed work, not an equal +percentage reduction in elapsed time. + +| Case, one allowed CPU | Baseline instructions | Candidate instructions | GNU find instructions | +| :--------------------------- | --------------------: | ---------------------: | --------------------: | +| Broad listing, 100 files | 1,904,767 | 1,727,276 | 566,412 | +| Broad listing, 100,000 files | 233,207,036 | 218,843,739 | 106,212,516 | +| Deep listing, 100,000 files | 245,730,492 | 220,817,669 | 110,644,735 | + +The candidate removes 9.32%, 6.16% and 10.14% of the baseline's instructions respectively. +Large listings still execute approximately twice find's userspace instructions. CPU sampling +of the final broad listing attributes about 18% of userspace cycles to the run visitor, 18% to +`readdir`, 13% to explicit path output, 8% to string append and 4% to the compact evaluator. +These are sampling shares of userspace cycles, not shares of elapsed time or exact savings +available from deleting a function. + +The next investigations should follow this evidence: + +1. Move run-invariant evaluation options out of per-entry construction; instantiate deferred maps, + captures and other optional state only when a consumer needs them. Preserve independent entry + state and sparse deferred replay. Measure narrow changes before redesigning the context API. +2. Trace the remaining path copies and sink dispatch through traversal, explicit output and + implicit listing. Keep complete-record boundaries, arbitrary path bytes and bounded storage. +3. Reduce startup construction of unused archive format/help vocabulary. The name lookup is now + lazy, but reader and packer registration still constructs descriptive records before `main`. +4. Compare directory-entry materialization with find using syscall counts and CPU samples before + changing VFS buffering. Adding threads is not an evidence-based default for these basic tasks. + +An additional high-density startup profile is retained separately. Loader work is visible, but +the ELF inventory does not support blaming extra shared libraries: XFF has fewer direct dynamic +dependencies and relocations than this GNU find executable. Startup symbol samples identify +investigation targets; they do not prove the savings from changing registration or linking. + +## Correctness checks + +The C++ regressions cover: + +- archive reader replacement/removal, shared suffixes, override vocabulary and concurrent first use; +- all boolean operators against the existing execution engines, including reached actions and + metadata failures on either side of an operator; +- mixed newline/NUL explicit output, record boundaries, reusable capacity and oversized records; +- long/short alternating child names, lazy metadata resolution, and complete child paths. +- native case resolution only when exact/folded answers differ, negated character classes, + cached sensitive and insensitive outcomes, fuzzy matching, and metadata failure under negation. + +The existing expression, deferred, fuzzy, content cache, traversal and parallel-matching suites +remain part of qualification. Each implementation change passed its focused macOS targets. +The native-case Linux gate runs 18 targets across the archive extras, content snapshot, evaluator, +whole-run behavior, parallel matching, expression engines, record buffer, walker and glob matching. +Eight focused Mac targets cover the native-case change. Additional run tests cover cached +case-sensitive resolution and fuzzy behavior on both platforms. + +The reporting change keeps experimental endpoint summaries keyed by full source SHA instead of +colliding at PR zero. Experiment catalogs carry a separate source label and no fabricated PR link. +The comparison's platform comes from its recorded contract. An experiment-only viewer selects +its available source automatically instead of opening on an empty merged-history selection. +Unmerged comparison sliders now put the baseline first and the candidate second, with an explicit +Comparison row in the Version card. The collector manifest uses the opposite order to choose +its fixed baseline; leaking that order into the viewer previously made the old binary appear +to be the newer measurement. The timing data and arithmetic are unchanged. +Nine report regression tests pass, +including experimental endpoint identities and renderer populations. + +Across the four incremental Linux stages, two combined comparisons and three native-case +comparisons, independent audits reconcile 726 cells and 60,984 validated invocations with their +raw journals. They rehash the retained executables, build identities and ThinLTO link actions, +check matching configurations and independently reproduce the exported timing arithmetic. +The four full viewer exports also have independent figure audits and Chromium checks of all +24 dataset/revision/order/metric states per export. Missing measurements remain gaps. + +## Retained evidence + +The complete campaign, source bundles, production binaries, link commands, raw samples and logs +are retained below: + +- macOS checkout: `bazel-extended-history-20261107/find-listing/`; +- Drogon: `/home/marcus/Documents/xff-chart-campaign-20261107/find-listing/`. + +Subdirectories `archive-gate`, `compact-evaluation`, `record-buffer-qualified` and `directory-prefix` +contain incremental comparisons. `combined` contains the Linux comparison against the original +baseline; `macos` contains the corresponding Mac comparison and its explicit collector adapter. +The adapter changes host evidence, GNU-tool locations, RAM-storage validation and CPU affinity; +workload construction, output validation, interleaving and timing code remain the same. + +`native-case` and `native-case-macos` retain the fifth change's Linux and Mac populations; +`native-case-repeat` retains the seven-case Linux repeat and its selection rationale. The final +result JSON records each comparison's baseline, candidate, executable hashes and per-cell +intervals. `profiles-final` and `profiles-startup-period` retain diagnostics excluded from timing +populations. Local previews are served from port 56205 under `find-listing-combined/`, +`find-listing-macos/`, `find-listing-native-case/` and `find-listing-native-case-macos/`. + +`record-buffer` preserves an aborted build attempt whose abbreviated source SHA failed the +builder's full-revision identity check. No measurement from that attempt was accepted. The launch +script now resolves commit arguments to full SHAs before freezing a build manifest. + +## Integration with current main + +The PR branch merges `3b8a8a34e7` after the measurements. Its overlap with #1134 is resolved by +keeping lexical-template metadata demand and independent fuzzy-score collection, while retaining +lazy native-case resolution. The results above refer to their recorded source and executable +hashes; the integrated PR binary has not been remeasured. Focused correctness checks qualify the +combined metadata paths separately from the retained performance populations. All 14 focused +Bazel targets passed after integration: nine engine/field targets and five extended-benchmark +and landscape targets. The Chromium history-control regression also passed with the comparison +role visible. The local demos were regenerated from unchanged raw measurements. diff --git a/docs/benchmarks/lazy-content-state-20261107.json b/docs/benchmarks/lazy-content-state-20261107.json new file mode 100644 index 00000000000..101c3232dcf --- /dev/null +++ b/docs/benchmarks/lazy-content-state-20261107.json @@ -0,0 +1,1567 @@ +{ + "experiment": "lazy inline content snapshot state", + "candidate": { + "sha": "90abd2b3ef63b35833e8f9d96745475c6b9f182a", + "pr": 0, + "date": "2026-11-07", + "subject": "EXPERIMENT ONLY: lazy inline content state (not a merged PR)", + "binary": "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "build_sha256": "76aefab8544695e29ab007490f0b7804de6218e28abe9b8261fbf79b253aae76", + "link_actions_sha256": "f5110fe044109e9fcde2e29e07047b852fb089dff93e1d074fc5d0d105173138" + }, + "baseline": { + "sha": "ae8c5af3eb11dc8571f11db9b307b0db948f78c6", + "date": "2026-11-07T11:11:19Z", + "subject": "Stop main benchmarks once three of four candidates agree (#1130)", + "pr": 1130, + "binary": "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "build_sha256": "b2047fd05cf98338b40681258b1b48bcc8c5b109865247cd7b92b45b37467008", + "link_actions_sha256": "f5110fe044109e9fcde2e29e07047b852fb089dff93e1d074fc5d0d105173138" + }, + "contract_sha256": "f6cc66c5dab993723dacdea2acc746eafa2e7d2e3987fe6c67226f45c6fe539b", + "complete_cells": 120, + "repetitions": 27, + "keep": 21, + "identical_baseline_control_p95_factor": 1.0206421466195383, + "workloads": [ + { + "task": "files-exact", + "files": 100, + "candidate_over_baseline": 0.9858060094933366, + "candidate_over_reference": 1.453135834858783, + "candidate_cpu_over_reference": 1.897324018668956 + }, + { + "task": "files-exact", + "files": 10000, + "candidate_over_baseline": 0.9867322285050354, + "candidate_over_reference": 1.3413910627757493, + "candidate_cpu_over_reference": 1.424889871530164 + }, + { + "task": "files-exact", + "files": 100000, + "candidate_over_baseline": 0.9932911787786122, + "candidate_over_reference": 1.1476270614548731, + "candidate_cpu_over_reference": 1.162097480538575 + }, + { + "task": "name-native", + "files": 100, + "candidate_over_baseline": 0.9882950547855832, + "candidate_over_reference": 1.443279044500081, + "candidate_cpu_over_reference": 1.862700937559108 + }, + { + "task": "name-native", + "files": 10000, + "candidate_over_baseline": 0.9847297664928557, + "candidate_over_reference": 1.2326522906688135, + "candidate_cpu_over_reference": 1.2861737283437586 + }, + { + "task": "name-native", + "files": 100000, + "candidate_over_baseline": 0.9915891868117679, + "candidate_over_reference": 1.085069094796375, + "candidate_cpu_over_reference": 1.0917758499163792 + }, + { + "task": "metadata-time", + "files": 100, + "candidate_over_baseline": 0.9887256319635018, + "candidate_over_reference": 1.4440790127523742, + "candidate_cpu_over_reference": 1.8191897404193644 + }, + { + "task": "metadata-time", + "files": 10000, + "candidate_over_baseline": 1.001410540204881, + "candidate_over_reference": 1.2338321894925406, + "candidate_cpu_over_reference": 1.2598889812896763 + }, + { + "task": "metadata-time", + "files": 100000, + "candidate_over_baseline": 1.0018598689513718, + "candidate_over_reference": 1.142547519736291, + "candidate_cpu_over_reference": 1.1491331278554358 + }, + { + "task": "content-regex", + "files": 100, + "candidate_over_baseline": 0.9844990596373772, + "candidate_over_reference": 0.7252122104550979, + "candidate_cpu_over_reference": 0.8289866934062279 + }, + { + "task": "content-regex", + "files": 10000, + "candidate_over_baseline": 0.9864603286992817, + "candidate_over_reference": 0.6425209693964369, + "candidate_cpu_over_reference": 0.6157974591123662 + }, + { + "task": "content-regex", + "files": 100000, + "candidate_over_baseline": 0.9976360981721317, + "candidate_over_reference": 0.7167149765955936, + "candidate_cpu_over_reference": 0.6406678937330853 + }, + { + "task": "archive-tar", + "files": 100, + "candidate_over_baseline": 0.980918818464372, + "candidate_over_reference": 1.355497387992729, + "candidate_cpu_over_reference": 1.714198659285517 + }, + { + "task": "archive-tar", + "files": 1000, + "candidate_over_baseline": 0.9896693299085171, + "candidate_over_reference": 1.0897052304200312, + "candidate_cpu_over_reference": 1.321979671818175 + }, + { + "task": "archive-tar", + "files": 10000, + "candidate_over_baseline": 0.9956660078501517, + "candidate_over_reference": 0.8674400514956654, + "candidate_cpu_over_reference": 1.0344942227318306 + } + ], + "cells": [ + { + "task": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9908269503462269, + "paired_ratio_ci_low": 0.9667321098410673, + "paired_ratio_ci_high": 1.0005608837291375, + "candidate_cpu_over_baseline": 0.976766190075694, + "candidate_rss_bytes": 7168195.047619048, + "baseline_rss_bytes": 7097002.666666667 + }, + { + "task": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9802028132560826, + "paired_ratio_ci_low": 0.9589817226076524, + "paired_ratio_ci_high": 1.0058094763897534, + "candidate_cpu_over_baseline": 0.9794501133786849, + "candidate_rss_bytes": 7216371.80952381, + "baseline_rss_bytes": 7045705.142857143 + }, + { + "task": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9742383758191483, + "paired_ratio_ci_low": 0.9287393502794693, + "paired_ratio_ci_high": 1.0236962460080103, + "candidate_cpu_over_baseline": 0.9721710500529144, + "candidate_rss_bytes": 8506221.714285715, + "baseline_rss_bytes": 8427812.57142857 + }, + { + "task": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.979456390761668, + "paired_ratio_ci_low": 0.935371273489191, + "paired_ratio_ci_high": 1.010367697959448, + "candidate_cpu_over_baseline": 0.9780045750483899, + "candidate_rss_bytes": 8554593.523809524, + "baseline_rss_bytes": 8390558.476190476 + }, + { + "task": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9903574223680647, + "paired_ratio_ci_low": 0.9850898808671936, + "paired_ratio_ci_high": 0.9940215857946038, + "candidate_cpu_over_baseline": 0.9905583778815585, + "candidate_rss_bytes": 20678363.42857143, + "baseline_rss_bytes": 20584350.476190478 + }, + { + "task": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9901837589467314, + "paired_ratio_ci_low": 0.9805021589939561, + "paired_ratio_ci_high": 1.0052686275409255, + "candidate_cpu_over_baseline": 0.9892185462513611, + "candidate_rss_bytes": 20688896.0, + "baseline_rss_bytes": 20638768.76190476 + }, + { + "task": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9804990920591494, + "paired_ratio_ci_low": 0.9595922864134739, + "paired_ratio_ci_high": 0.9950227350242604, + "candidate_cpu_over_baseline": 0.9766747527523791, + "candidate_rss_bytes": 7191405.714285715, + "baseline_rss_bytes": 7039073.523809524 + }, + { + "task": "files-exact", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9917561308345428, + "paired_ratio_ci_low": 0.9572114258616026, + "paired_ratio_ci_high": 0.9977429470523929, + "candidate_cpu_over_baseline": 0.9913288625005339, + "candidate_rss_bytes": 7183603.80952381, + "baseline_rss_bytes": 7053507.047619048 + }, + { + "task": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9710214060869374, + "paired_ratio_ci_low": 0.9549451598237381, + "paired_ratio_ci_high": 0.9958475510405714, + "candidate_cpu_over_baseline": 0.9653262914322557, + "candidate_rss_bytes": 7930246.095238095, + "baseline_rss_bytes": 7815948.19047619 + }, + { + "task": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0231000649476785, + "paired_ratio_ci_low": 1.0078570578180843, + "paired_ratio_ci_high": 1.0545931566641606, + "candidate_cpu_over_baseline": 1.0200043468811129, + "candidate_rss_bytes": 7957942.857142857, + "baseline_rss_bytes": 7855542.857142857 + }, + { + "task": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9949231214824098, + "paired_ratio_ci_low": 0.9925906381872405, + "paired_ratio_ci_high": 1.0056514976565698, + "candidate_cpu_over_baseline": 0.9939446292222636, + "candidate_rss_bytes": 14635203.047619049, + "baseline_rss_bytes": 14463171.047619049 + }, + { + "task": "files-exact", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9977208111599393, + "paired_ratio_ci_low": 0.9825663300863491, + "paired_ratio_ci_high": 1.0091610870172856, + "candidate_cpu_over_baseline": 0.9968630321043385, + "candidate_rss_bytes": 14633057.523809524, + "baseline_rss_bytes": 14419870.476190476 + }, + { + "task": "name-native", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9758017780783093, + "paired_ratio_ci_low": 0.9484526091675857, + "paired_ratio_ci_high": 0.9872649913082621, + "candidate_cpu_over_baseline": 0.9708925300727687, + "candidate_rss_bytes": 7160783.238095238, + "baseline_rss_bytes": 7049996.19047619 + }, + { + "task": "name-native", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9999896305206584, + "paired_ratio_ci_low": 0.982905028416302, + "paired_ratio_ci_high": 1.015466021689984, + "candidate_cpu_over_baseline": 0.9971691776221092, + "candidate_rss_bytes": 7151225.904761905, + "baseline_rss_bytes": 7064234.666666667 + }, + { + "task": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9792167760182129, + "paired_ratio_ci_low": 0.9681582491676326, + "paired_ratio_ci_high": 1.00830295744107, + "candidate_cpu_over_baseline": 0.9720684755396172, + "candidate_rss_bytes": 8502320.761904761, + "baseline_rss_bytes": 8403626.666666666 + }, + { + "task": "name-native", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9751470336531453, + "paired_ratio_ci_low": 0.9420840430190732, + "paired_ratio_ci_high": 1.0262658493007397, + "candidate_cpu_over_baseline": 0.9716878484335213, + "candidate_rss_bytes": 8520070.095238095, + "baseline_rss_bytes": 8405187.047619049 + }, + { + "task": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9894122062020164, + "paired_ratio_ci_low": 0.987234897170934, + "paired_ratio_ci_high": 0.9931879144473447, + "candidate_cpu_over_baseline": 0.9888015646017623, + "candidate_rss_bytes": 20696112.76190476, + "baseline_rss_bytes": 20533833.14285714 + }, + { + "task": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9947297105904997, + "paired_ratio_ci_low": 0.981334009879904, + "paired_ratio_ci_high": 0.998386998509877, + "candidate_cpu_over_baseline": 0.9937277449962999, + "candidate_rss_bytes": 20709961.14285714, + "baseline_rss_bytes": 20574208.0 + }, + { + "task": "name-native", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9880609786124355, + "paired_ratio_ci_low": 0.9547346258001349, + "paired_ratio_ci_high": 1.0014298028562194, + "candidate_cpu_over_baseline": 0.9874242702404995, + "candidate_rss_bytes": 7183603.80952381, + "baseline_rss_bytes": 7050581.333333333 + }, + { + "task": "name-native", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9894768532055386, + "paired_ratio_ci_low": 0.954985146521211, + "paired_ratio_ci_high": 0.9981125761572148, + "candidate_cpu_over_baseline": 0.9866923406076165, + "candidate_rss_bytes": 7165659.428571428, + "baseline_rss_bytes": 7099148.19047619 + }, + { + "task": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9903123369143285, + "paired_ratio_ci_low": 0.9858798144823907, + "paired_ratio_ci_high": 1.017380886222604, + "candidate_cpu_over_baseline": 0.9863640822733069, + "candidate_rss_bytes": 7970816.0, + "baseline_rss_bytes": 7883044.571428572 + }, + { + "task": "name-native", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9943679673270344, + "paired_ratio_ci_low": 0.9505283844450164, + "paired_ratio_ci_high": 1.009347868763928, + "candidate_cpu_over_baseline": 0.9888536977340865, + "candidate_rss_bytes": 7935122.285714285, + "baseline_rss_bytes": 7878168.380952381 + }, + { + "task": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.993912237858147, + "paired_ratio_ci_low": 0.9907216727684288, + "paired_ratio_ci_high": 1.00027773822769, + "candidate_cpu_over_baseline": 0.9930139012126591, + "candidate_rss_bytes": 14628376.38095238, + "baseline_rss_bytes": 14448152.38095238 + }, + { + "task": "name-native", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9883180729163441, + "paired_ratio_ci_low": 0.9749161137653896, + "paired_ratio_ci_high": 0.9975500264573897, + "candidate_cpu_over_baseline": 0.9878594836474971, + "candidate_rss_bytes": 14637933.714285715, + "baseline_rss_bytes": 14536508.952380951 + }, + { + "task": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9915616623166402, + "paired_ratio_ci_low": 0.9719146287485804, + "paired_ratio_ci_high": 1.0062416809519295, + "candidate_cpu_over_baseline": 0.9813061304178057, + "candidate_rss_bytes": 7165659.428571428, + "baseline_rss_bytes": 7014887.619047619 + }, + { + "task": "metadata-time", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 1.002133319908408, + "paired_ratio_ci_low": 0.9725038004731501, + "paired_ratio_ci_high": 1.0239805960111381, + "candidate_cpu_over_baseline": 0.9929048219203657, + "candidate_rss_bytes": 7145764.571428572, + "baseline_rss_bytes": 7056237.714285715 + }, + { + "task": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0152589758181207, + "paired_ratio_ci_low": 0.9785156051812884, + "paired_ratio_ci_high": 1.0255724302083604, + "candidate_cpu_over_baseline": 1.0167595651163168, + "candidate_rss_bytes": 8556739.047619049, + "baseline_rss_bytes": 8375539.80952381 + }, + { + "task": "metadata-time", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9958895553448656, + "paired_ratio_ci_low": 0.9669282135108274, + "paired_ratio_ci_high": 1.0253729840461934, + "candidate_cpu_over_baseline": 0.9968967688417604, + "candidate_rss_bytes": 8501345.523809524, + "baseline_rss_bytes": 8394459.42857143 + }, + { + "task": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.004916199577144, + "paired_ratio_ci_low": 1.0022484225377941, + "paired_ratio_ci_high": 1.0084898624669454, + "candidate_cpu_over_baseline": 1.0050975726524116, + "candidate_rss_bytes": 20693967.23809524, + "baseline_rss_bytes": 20610681.904761903 + }, + { + "task": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0011006928688548, + "paired_ratio_ci_low": 0.9901508155816272, + "paired_ratio_ci_high": 1.0229300725622712, + "candidate_cpu_over_baseline": 1.0013241374132271, + "candidate_rss_bytes": 20705280.0, + "baseline_rss_bytes": 20542220.19047619 + }, + { + "task": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9863546373908085, + "paired_ratio_ci_low": 0.9658014240647792, + "paired_ratio_ci_high": 1.0054129518738624, + "candidate_cpu_over_baseline": 0.9761330663288241, + "candidate_rss_bytes": 7325208.380952381, + "baseline_rss_bytes": 7241728.0 + }, + { + "task": "metadata-time", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9750454327669156, + "paired_ratio_ci_low": 0.9602238960408122, + "paired_ratio_ci_high": 1.0140239695553286, + "candidate_cpu_over_baseline": 0.9648500114495079, + "candidate_rss_bytes": 7300437.333333333, + "baseline_rss_bytes": 7204083.80952381 + }, + { + "task": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 1.0069689103896022, + "paired_ratio_ci_low": 0.9940114405670868, + "paired_ratio_ci_high": 1.0196258700910263, + "candidate_cpu_over_baseline": 1.0077208421383466, + "candidate_rss_bytes": 8609792.0, + "baseline_rss_bytes": 8486716.952380951 + }, + { + "task": "metadata-time", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9877443525088787, + "paired_ratio_ci_low": 0.9533581088145184, + "paired_ratio_ci_high": 1.0163402810861755, + "candidate_cpu_over_baseline": 0.9860643465180196, + "candidate_rss_bytes": 8651337.142857144, + "baseline_rss_bytes": 8453753.904761905 + }, + { + "task": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9972883604568276, + "paired_ratio_ci_low": 0.9927756100104572, + "paired_ratio_ci_high": 1.0024571211305067, + "candidate_cpu_over_baseline": 0.9973961834302513, + "candidate_rss_bytes": 21082697.14285714, + "baseline_rss_bytes": 20942652.95238095 + }, + { + "task": "metadata-time", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0041522435383854, + "paired_ratio_ci_low": 0.9901242237083502, + "paired_ratio_ci_high": 1.0218897249098666, + "candidate_cpu_over_baseline": 1.0041976094515375, + "candidate_rss_bytes": 21088548.57142857, + "baseline_rss_bytes": 20936606.476190478 + }, + { + "task": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9745497410740592, + "paired_ratio_ci_low": 0.9364998606360144, + "paired_ratio_ci_high": 0.9828338329858666, + "candidate_cpu_over_baseline": 0.9709820467559305, + "candidate_rss_bytes": 7174436.571428572, + "baseline_rss_bytes": 7070281.142857143 + }, + { + "task": "content-regex", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9912926181339579, + "paired_ratio_ci_low": 0.9695721844073641, + "paired_ratio_ci_high": 1.0125049474210237, + "candidate_cpu_over_baseline": 0.968389564817212, + "candidate_rss_bytes": 7211885.714285715, + "baseline_rss_bytes": 7051946.666666667 + }, + { + "task": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.99429290429129, + "paired_ratio_ci_low": 0.9730338508761448, + "paired_ratio_ci_high": 0.9969985837133502, + "candidate_cpu_over_baseline": 0.994685644307863, + "candidate_rss_bytes": 8496079.238095239, + "baseline_rss_bytes": 8403041.523809524 + }, + { + "task": "content-regex", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9866307146433356, + "paired_ratio_ci_low": 0.9501617736527707, + "paired_ratio_ci_high": 1.0039238318778563, + "candidate_cpu_over_baseline": 0.9827330719649146, + "candidate_rss_bytes": 9117110.857142856, + "baseline_rss_bytes": 8948589.714285715 + }, + { + "task": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9959912638821006, + "paired_ratio_ci_low": 0.9924272227808281, + "paired_ratio_ci_high": 0.9984269613309487, + "candidate_cpu_over_baseline": 0.995923486680921, + "candidate_rss_bytes": 20716982.85714286, + "baseline_rss_bytes": 20570502.095238097 + }, + { + "task": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 0.9964246767968664, + "paired_ratio_ci_low": 0.9700278332771783, + "paired_ratio_ci_high": 1.0018452334828956, + "candidate_cpu_over_baseline": 0.9970237777057132, + "candidate_rss_bytes": 20665880.38095238, + "baseline_rss_bytes": 20562310.095238097 + }, + { + "task": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9922685770947861, + "paired_ratio_ci_low": 0.9756407211503101, + "paired_ratio_ci_high": 1.0131729183363665, + "candidate_cpu_over_baseline": 0.9874861527099661, + "candidate_rss_bytes": 7189845.333333333, + "baseline_rss_bytes": 7105389.714285715 + }, + { + "task": "content-regex", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9800000584408967, + "paired_ratio_ci_low": 0.968036552432725, + "paired_ratio_ci_high": 1.0094316649990598, + "candidate_cpu_over_baseline": 0.9741915683156164, + "candidate_rss_bytes": 7346273.523809524, + "baseline_rss_bytes": 7226709.333333333 + }, + { + "task": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9903506831147603, + "paired_ratio_ci_low": 0.9736712257161401, + "paired_ratio_ci_high": 1.0010052108703908, + "candidate_cpu_over_baseline": 0.9900290888302254, + "candidate_rss_bytes": 7925369.904761905, + "baseline_rss_bytes": 7851446.857142857 + }, + { + "task": "content-regex", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9746765578020621, + "paired_ratio_ci_low": 0.9579525577399393, + "paired_ratio_ci_high": 0.9972258471744002, + "candidate_cpu_over_baseline": 0.9745842392901218, + "candidate_rss_bytes": 9264956.952380951, + "baseline_rss_bytes": 9149293.714285715 + }, + { + "task": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9975800245922536, + "paired_ratio_ci_low": 0.9940962565574508, + "paired_ratio_ci_high": 0.9994760340566897, + "candidate_cpu_over_baseline": 0.9975230548183094, + "candidate_rss_bytes": 14636763.42857143, + "baseline_rss_bytes": 14540409.904761905 + }, + { + "task": "content-regex", + "shape": "deep", + "files": 100000, + "cpus": 3, + "candidate_over_baseline": 1.0005547836824058, + "paired_ratio_ci_low": 0.9778485829882491, + "paired_ratio_ci_high": 1.0153607472765491, + "candidate_cpu_over_baseline": 1.0030197898714317, + "candidate_rss_bytes": 16123806.476190476, + "baseline_rss_bytes": 15993904.761904761 + }, + { + "task": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.977455519213255, + "paired_ratio_ci_low": 0.9579481700215291, + "paired_ratio_ci_high": 0.9899985231320151, + "candidate_cpu_over_baseline": 0.9775891665077244, + "candidate_rss_bytes": 7674928.761904762, + "baseline_rss_bytes": 7540931.047619048 + }, + { + "task": "archive-tar", + "shape": "broad", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9871537957539773, + "paired_ratio_ci_low": 0.9698036347727708, + "paired_ratio_ci_high": 1.0063109422170688, + "candidate_cpu_over_baseline": 0.9874256875240581, + "candidate_rss_bytes": 7666346.666666667, + "baseline_rss_bytes": 7569603.047619048 + }, + { + "task": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9996949355009934, + "paired_ratio_ci_low": 0.966399044549602, + "paired_ratio_ci_high": 1.028404421957112, + "candidate_cpu_over_baseline": 0.9933139865710708, + "candidate_rss_bytes": 7777328.761904762, + "baseline_rss_bytes": 7734028.19047619 + }, + { + "task": "archive-tar", + "shape": "broad", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.982416814871655, + "paired_ratio_ci_low": 0.9675675054771852, + "paired_ratio_ci_high": 1.0072962761823483, + "candidate_cpu_over_baseline": 0.9681993697572234, + "candidate_rss_bytes": 7806390.857142857, + "baseline_rss_bytes": 7719984.761904762 + }, + { + "task": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9905422167146773, + "paired_ratio_ci_low": 0.9827643527194676, + "paired_ratio_ci_high": 0.9961601062314008, + "candidate_cpu_over_baseline": 0.9969193624617769, + "candidate_rss_bytes": 10343960.38095238, + "baseline_rss_bytes": 10195724.19047619 + }, + { + "task": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9926885589503676, + "paired_ratio_ci_low": 0.9842844170648465, + "paired_ratio_ci_high": 0.9997894250590255, + "candidate_cpu_over_baseline": 0.9911773441996029, + "candidate_rss_bytes": 10308851.80952381, + "baseline_rss_bytes": 10204891.42857143 + }, + { + "task": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9837102585598202, + "paired_ratio_ci_low": 0.9674607910357119, + "paired_ratio_ci_high": 1.0047625310070103, + "candidate_cpu_over_baseline": 0.9807141493221309, + "candidate_rss_bytes": 7658349.714285715, + "baseline_rss_bytes": 7564726.857142857 + }, + { + "task": "archive-tar", + "shape": "deep", + "files": 100, + "cpus": 3, + "candidate_over_baseline": 0.9754011021372153, + "paired_ratio_ci_low": 0.9416666671543429, + "paired_ratio_ci_high": 0.9992225324257125, + "candidate_cpu_over_baseline": 0.9570701932858595, + "candidate_rss_bytes": 7671417.904761905, + "baseline_rss_bytes": 7582476.19047619 + }, + { + "task": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 1, + "candidate_over_baseline": 0.9991627609967942, + "paired_ratio_ci_low": 0.9707110119462136, + "paired_ratio_ci_high": 1.0102662618779832, + "candidate_cpu_over_baseline": 1.0066777529491242, + "candidate_rss_bytes": 7829601.523809524, + "baseline_rss_bytes": 7660300.19047619 + }, + { + "task": "archive-tar", + "shape": "deep", + "files": 1000, + "cpus": 3, + "candidate_over_baseline": 0.9775994032207883, + "paired_ratio_ci_low": 0.9622760325017813, + "paired_ratio_ci_high": 0.9959264301168738, + "candidate_cpu_over_baseline": 0.981263060957036, + "candidate_rss_bytes": 7911326.476190476, + "baseline_rss_bytes": 7791372.19047619 + }, + { + "task": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9972903049915448, + "paired_ratio_ci_low": 0.9911941532869082, + "paired_ratio_ci_high": 1.0004078664345784, + "candidate_cpu_over_baseline": 0.9979843800528936, + "candidate_rss_bytes": 11818715.42857143, + "baseline_rss_bytes": 11737575.61904762 + }, + { + "task": "archive-tar", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 1.0021832008929241, + "paired_ratio_ci_low": 0.9920556072949624, + "paired_ratio_ci_high": 1.0176886141191288, + "candidate_cpu_over_baseline": 1.0008804232156119, + "candidate_rss_bytes": 11838805.333333334, + "baseline_rss_bytes": 11749083.42857143 + } + ], + "pr_zero_is_experiment_only": true, + "raw_evidence_root": "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content", + "instruction_diagnostics": { + "utc": "2026-11-07T16:00:37.605875+00:00", + "diagnostic_only": true, + "repetitions": 7, + "output_destination": "/dev/null; independent output oracle checked before each profile", + "purpose": "Count user-space instructions in retained production binaries; excluded from timing datasets.", + "results": [ + { + "case": "files-exact/broad/100/1", + "participant": "xff", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "events": { + "instructions:u": 1904808.0, + "cycles:u": 2240120.0, + "branches:u": 397778.0, + "branch-misses:u": 24505.0 + }, + "raw": "files-exact-broad-100-1-xff.tsv", + "raw_sha256": "5b4ed9edb33cd150424f99a6def124f4d7b9f01ace48e48c8868f2135cb5e197", + "preprofile_stdout_sha256": "6c6a955e99ddb8ee7f20e644ebd13d65aad07b5f06504716b3b776248c409bd4", + "affinity": [0] + }, + { + "case": "files-exact/broad/100/1", + "participant": "anchor", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "events": { + "instructions:u": 1911425.0, + "cycles:u": 2146944.0, + "branches:u": 399178.0, + "branch-misses:u": 24819.0 + }, + "raw": "files-exact-broad-100-1-anchor.tsv", + "raw_sha256": "3acb1dcb1095cfdd7fb73445bb41f90d377557a22471518d3e728810b3f6800f", + "preprofile_stdout_sha256": "6c6a955e99ddb8ee7f20e644ebd13d65aad07b5f06504716b3b776248c409bd4", + "affinity": [0] + }, + { + "case": "files-exact/broad/10000/1", + "participant": "xff", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "events": { + "instructions:u": 24827442.0, + "cycles:u": 7531005.0, + "branches:u": 4539344.0, + "branch-misses:u": 25862.0 + }, + "raw": "files-exact-broad-10000-1-xff.tsv", + "raw_sha256": "cee70784d6cdf270af6a0f8858c1f834c902490a3802601bb76e3c23755e551f", + "preprofile_stdout_sha256": "44378dfdd1346bedbd668fe132fbbbe9449d4230197769b78df9d88c45be2394", + "affinity": [0] + }, + { + "case": "files-exact/broad/10000/1", + "participant": "anchor", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "events": { + "instructions:u": 25487490.0, + "cycles:u": 7687586.0, + "branches:u": 4679352.0, + "branch-misses:u": 25344.0 + }, + "raw": "files-exact-broad-10000-1-anchor.tsv", + "raw_sha256": "b967a21ce5c885e2085fe8d76a7b155f2471e9e6581067ae24391b581d9470c0", + "preprofile_stdout_sha256": "44378dfdd1346bedbd668fe132fbbbe9449d4230197769b78df9d88c45be2394", + "affinity": [0] + }, + { + "case": "files-exact/broad/100000/1", + "participant": "xff", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "events": { + "instructions:u": 233207020.0, + "cycles:u": 59888812.0, + "branches:u": 42187733.0, + "branch-misses:u": 37065.0 + }, + "raw": "files-exact-broad-100000-1-xff.tsv", + "raw_sha256": "9e3c8dc29b094b52c190462bc21b7f1bf737ff93b6fe096030272357d6789760", + "preprofile_stdout_sha256": "6ff2bd4158063702766a047565dbcfcd12933967b0e9b9f8cdaa52f8a5165bcd", + "affinity": [0] + }, + { + "case": "files-exact/broad/100000/1", + "participant": "anchor", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "events": { + "instructions:u": 239807162.0, + "cycles:u": 62454376.0, + "branches:u": 43587822.0, + "branch-misses:u": 43316.0 + }, + "raw": "files-exact-broad-100000-1-anchor.tsv", + "raw_sha256": "dc6b6efcf005448b021ce13e579c1b39dd02753a9dc4531fce20ed01ea95f1ae", + "preprofile_stdout_sha256": "6ff2bd4158063702766a047565dbcfcd12933967b0e9b9f8cdaa52f8a5165bcd", + "affinity": [0] + }, + { + "case": "files-exact/deep/100000/1", + "participant": "xff", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "events": { + "instructions:u": 245730529.0, + "cycles:u": 60759151.0, + "branches:u": 45188063.0, + "branch-misses:u": 59001.0 + }, + "raw": "files-exact-deep-100000-1-xff.tsv", + "raw_sha256": "4706e46b1dc038957ed4a82a69f1036d149246a1c14a05f008b2dec1be89a60c", + "preprofile_stdout_sha256": "94500dcde3b2fe96d13e711e763bf92fb5e7064e27dd6ac076f88a0a7d290999", + "affinity": [0] + }, + { + "case": "files-exact/deep/100000/1", + "participant": "anchor", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + ".", + "-type", + "f", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "events": { + "instructions:u": 252332090.0, + "cycles:u": 62437644.0, + "branches:u": 46588331.0, + "branch-misses:u": 58711.0 + }, + "raw": "files-exact-deep-100000-1-anchor.tsv", + "raw_sha256": "a05ddad0a5e0ffaaeb87a4665234aedb3c89d335e955e3c809cf0170012cc481", + "preprofile_stdout_sha256": "94500dcde3b2fe96d13e711e763bf92fb5e7064e27dd6ac076f88a0a7d290999", + "affinity": [0] + }, + { + "case": "metadata-time/broad/100000/1", + "participant": "xff", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + "--timezone=UTC", + "/dev/shm/xff-lazy-content-20261107/native/broad/100000", + "-type", + "f", + "-name", + "*.txt", + "-size", + "+128c", + "-printf", + "%p\\t%s\\t%TY-%Tm-%Td\\0" + ], + "exit_code": 0, + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "events": { + "instructions:u": 589065424.0, + "cycles:u": 210359958.0, + "branches:u": 109444233.0, + "branch-misses:u": 719111.0 + }, + "raw": "metadata-time-broad-100000-1-xff.tsv", + "raw_sha256": "0068891e8292050b02a3337c210557eae54316b6cb605c7dc09ed12b36f06957", + "preprofile_stdout_sha256": "43e35b527111359aa7a2997fdaf5a7ccf5c7eed7c57ff9c5a7b656a193bbf8ae", + "affinity": [0] + }, + { + "case": "metadata-time/broad/100000/1", + "participant": "anchor", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + "--timezone=UTC", + "/dev/shm/xff-lazy-content-20261107/native/broad/100000", + "-type", + "f", + "-name", + "*.txt", + "-size", + "+128c", + "-printf", + "%p\\t%s\\t%TY-%Tm-%Td\\0" + ], + "exit_code": 0, + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "events": { + "instructions:u": 594265420.0, + "cycles:u": 203078186.0, + "branches:u": 110494217.0, + "branch-misses:u": 705163.0 + }, + "raw": "metadata-time-broad-100000-1-anchor.tsv", + "raw_sha256": "4fb74970d1f5772465417b8d83fffca41a9f48213015a01e340ba6eeac533032", + "preprofile_stdout_sha256": "43e35b527111359aa7a2997fdaf5a7ccf5c7eed7c57ff9c5a7b656a193bbf8ae", + "affinity": [0] + }, + { + "case": "content-regex/broad/100000/1", + "participant": "xff", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + "--case=sensitive", + "--regextype=RE2", + "/dev/shm/xff-lazy-content-20261107/native/broad/100000", + "-type", + "f", + "-name", + "*.txt", + "-rxc", + "(ERROR|WARN) service=api_[0-9]+ status=5[0-9]{2}", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "events": { + "instructions:u": 735366924.0, + "cycles:u": 290198140.0, + "branches:u": 177759949.0, + "branch-misses:u": 936115.0 + }, + "raw": "content-regex-broad-100000-1-xff.tsv", + "raw_sha256": "8f7429712dc7fed7d591b6fa7985a70ae1859c819bde3d68add2e783c51b0a6c", + "preprofile_stdout_sha256": "43ac4e9b76687b4229019be58767e7799a9409d5dc66fa2df23715d3b672828e", + "affinity": [0] + }, + { + "case": "content-regex/broad/100000/1", + "participant": "anchor", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + "--case=sensitive", + "--regextype=RE2", + "/dev/shm/xff-lazy-content-20261107/native/broad/100000", + "-type", + "f", + "-name", + "*.txt", + "-rxc", + "(ERROR|WARN) service=api_[0-9]+ status=5[0-9]{2}", + "-print0" + ], + "exit_code": 0, + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "events": { + "instructions:u": 737765795.0, + "cycles:u": 294312594.0, + "branches:u": 178193320.0, + "branch-misses:u": 1008787.0 + }, + "raw": "content-regex-broad-100000-1-anchor.tsv", + "raw_sha256": "5966d270c5f96ada06e1541961601e98650b3cc92f00e2629814295352badc0c", + "preprofile_stdout_sha256": "43ac4e9b76687b4229019be58767e7799a9409d5dc66fa2df23715d3b672828e", + "affinity": [0] + }, + { + "case": "archive-tar/broad/10000/1", + "participant": "xff", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/90abd2b3ef63b35833e8f9d96745475c6b9f182a/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + "--archive=roots", + "--archive-separator=/", + "fixture.tar", + "-type", + "f", + "-name", + "*.txt", + "-print" + ], + "exit_code": 0, + "binary_sha256": "585073ec9e982f603dcbaaf1bb9fa615720b9d0287041ef0012c01cc3ac1d2d3", + "events": { + "instructions:u": 147952428.0, + "cycles:u": 34325960.0, + "branches:u": 30005005.0, + "branch-misses:u": 101382.0 + }, + "raw": "archive-tar-broad-10000-1-xff.tsv", + "raw_sha256": "79e90aa0bff9fefebbd5c3378cdfe71b856c2c6014d70d29a1eddf1964609a27", + "preprofile_stdout_sha256": "1375a73687da8345bfa6fb0ce092fec3182e5fe661437abbff8bfe8074a69747", + "affinity": [0] + }, + { + "case": "archive-tar/broad/10000/1", + "participant": "anchor", + "command": [ + "/usr/bin/perf", + "stat", + "-x", + "\t", + "-r", + "7", + "-e", + "instructions:u,cycles:u,branches:u,branch-misses:u", + "--", + "/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content/build/binaries/ae8c5af3eb11dc8571f11db9b307b0db948f78c6/xff_full", + "--no-config", + "--no-pager", + "--color=never", + "--sort=none", + "--gitignore=off", + "--hidden", + "--jobs=1", + "--exact", + "--archive=roots", + "--archive-separator=/", + "fixture.tar", + "-type", + "f", + "-name", + "*.txt", + "-print" + ], + "exit_code": 0, + "binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "events": { + "instructions:u": 148481524.0, + "cycles:u": 34091409.0, + "branches:u": 30110701.0, + "branch-misses:u": 101556.0 + }, + "raw": "archive-tar-broad-10000-1-anchor.tsv", + "raw_sha256": "ea48c227a5a74146ae818f7b682aa2d267707d383b0602ad00143c3f9d63f022", + "preprofile_stdout_sha256": "1375a73687da8345bfa6fb0ce092fec3182e5fe661437abbff8bfe8074a69747", + "affinity": [0] + } + ] + }, + "configuration_reconciliation": { + "changed_generated_extension_cache": [ + "@@aspect_tools_telemetry+//:extension.bzl%telemetry" + ], + "original_baseline_lock_sha256": "7beb8ee87015728a993c8a28de544869e6c578739f0206383104337532f2870f", + "candidate_lock_sha256": "077380d17c357f5517927f3040d17073c70cd6f3a9cca81ecf87e7dfc49dca85", + "reproduced_baseline_binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "retained_baseline_binary_sha256": "c47c904b693c8c114bb87284497b98a10e4925f25afdc3f5ec4f26896ad1a2e1", + "reproduced_build_json_sha256": "6911fc0923aebf25bd4e033c3596b20673f840334c94d641f2478bb20ce0ebed", + "proof": "Same tracked inputs, only generated telemetry cache differs; baseline rebuilt with candidate configuration is byte-identical to the retained baseline." + }, + "arithmetic_audit": { + "checked_points": 1440, + "verified_missing_points": 480, + "max_error": 1.1102230246251565e-16, + "complete_revisions": 2, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "f6cc66c5dab993723dacdea2acc746eafa2e7d2e3987fe6c67226f45c6fe539b" + }, + "targeted_repeat": { + "contract_sha256": "8819005412453e9082391a3cfd8df413f4fb1d091e7cc14f7502ece9de1771a8", + "selection": "Two cells whose original paired intervals were slower, plus six fixed controls; a separate population.", + "cells": [ + { + "task": "files-exact", + "shape": "broad", + "files": 100, + "cpus": 1, + "candidate_over_baseline": 0.9859422923176014, + "paired_ratio_ci_low": 0.9730329448446121, + "paired_ratio_ci_high": 1.004206548564462 + }, + { + "task": "files-exact", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9908796034684778, + "paired_ratio_ci_low": 0.9703538127146377, + "paired_ratio_ci_high": 1.0118270065172348 + }, + { + "task": "files-exact", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9894508571503579, + "paired_ratio_ci_low": 0.9861470862089783, + "paired_ratio_ci_high": 0.993775057082928 + }, + { + "task": "files-exact", + "shape": "deep", + "files": 10000, + "cpus": 3, + "candidate_over_baseline": 0.9965589390985818, + "paired_ratio_ci_low": 0.9650740628542485, + "paired_ratio_ci_high": 1.0231012949797849 + }, + { + "task": "name-native", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.990106692255259, + "paired_ratio_ci_low": 0.9872992181554529, + "paired_ratio_ci_high": 0.9948637795678315 + }, + { + "task": "metadata-time", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 1.0049882927094906, + "paired_ratio_ci_low": 1.0016878998013148, + "paired_ratio_ci_high": 1.0181888882599819 + }, + { + "task": "content-regex", + "shape": "broad", + "files": 100000, + "cpus": 1, + "candidate_over_baseline": 0.9955498440060818, + "paired_ratio_ci_low": 0.9909017917081528, + "paired_ratio_ci_high": 0.9993233036006368 + }, + { + "task": "archive-tar", + "shape": "broad", + "files": 10000, + "cpus": 1, + "candidate_over_baseline": 0.9802470853526106, + "paired_ratio_ci_low": 0.964588041119861, + "paired_ratio_ci_high": 0.986986485820779 + } + ], + "arithmetic_audit": { + "checked_points": 192, + "verified_missing_points": 1248, + "max_error": 0, + "complete_revisions": 2, + "views": 2, + "script_sha256": "f38036edb7ba088e7a4401d7b66012f6b7b7fdbd78d62f654d5d4147cada245c", + "contract_sha256": "8819005412453e9082391a3cfd8df413f4fb1d091e7cc14f7502ece9de1771a8" + } + } +} diff --git a/docs/benchmarks/lazy-content-state-20261107.md b/docs/benchmarks/lazy-content-state-20261107.md new file mode 100644 index 00000000000..753a473f89f --- /dev/null +++ b/docs/benchmarks/lazy-content-state-20261107.md @@ -0,0 +1,127 @@ +# Lazy inline content snapshot state (2026-11-07) + +## Conclusion + +Adopt this implementation on `benchmark/extended-history-20261107`. Broad 100,000-file listing is +about 1% faster in both measurement populations, supported by a repeatable reduction in executed +instructions. A gain this small is still worth retaining even when it is hard to see on the 3D +chart. Broad metadata/date output is about 0.5% slower in both populations; that measured tradeoff +remains part of the adoption decision. This result supports this specific content-state change; +other uses of lazy inline storage need their own size and active-use measurements. + +The production changes and regression tests were copied unchanged from the measured source +`90abd2b3ef63b35833e8f9d96745475c6b9f182a`. The original experiment branch +`benchmark/lazy-content-state-20261107` and its raw evidence remain available. The historical +preview contains merged PRs and does not include this unmerged optimization; its timings remain +in the separate experiment population below. + +## Change and scope + +Candidate `90abd2b3ef63b35833e8f9d96745475c6b9f182a` moves the per-entry content snapshot's +bytes, digest map and line-count cache into inline `std::optional` storage. The state is +constructed only when a content consumer reaches it; invalidation destroys it. The owning +snapshot still reserves space for the state. Public read/cache/transfer behavior is unchanged. + +The explicit nonthrowing constructor initializes the optional to `std::nullopt`. This avoids +whole-snapshot zero-initialization when the snapshot is value-initialized inside its owner. +In a macOS ARM64 LLVM 23 construction probe, the original 88-byte snapshot requires several +stores covering its storage; the 96-byte candidate requires two byte stores. This probe alone +does not establish how the compiler initializes a complete evaluation context. + +The original empty map allocated nothing. This change reduces construction, destruction and +movement of unused cache state; it does not remove a per-entry map allocation. Existing lazy +storage in the walker, render buffers and parallel content results already uses similar patterns. +Replacing every owning pointer with inline storage would also change object sizes and lifetimes +and is not justified by this experiment. + +## Production comparison + +Baseline is PR #1130, `ae8c5af3eb11dc8571f11db9b307b0db948f78c6`. The experiment follows the +completed 130-revision extended benchmark campaign on drogon's Linux KVM guest. It uses frozen +full production binaries built with `--config=clang_release --config=xff_full`, including ThinLTO. +All compilation and baseline CPU sampling finished before the full candidate timing population +began. Instruction counting ran between that population and the separate targeted repeat. + +The five extended tasks, broad/deep fixtures and one/three allowed CPUs provide 60 cases. Each +case measures the candidate and an identical-baseline control in separate blocks; every block +interleaves its XFF binary, the fixed baseline and the traditional tool. There is one discarded +warm-up round and 27 measured rounds, retaining the fastest 21. Every invocation validates exact +output against an independent fixture oracle. Fixtures are on tmpfs. All 120 cells and 10,080 +invocations completed successfully. This population is separate from the historical campaign. + +The configuration guard initially stopped the experiment because an ignored, generated +`MODULE.bazel.lock` hash differed. Its only difference was the Aspect telemetry extension cache; +all tracked configuration inputs matched. Before allowing measurements, the baseline was rebuilt +in the candidate environment. Its executable was byte-identical to the retained baseline, and its +recorded configuration matched the candidate. Both lock files and the reproduction receipt are +retained in `lazy-content/configuration/` and `configuration-reconciliation.json`. + +## Elapsed results + +The table gives equally weighted geometric means over both shapes and CPU allowances. Negative +change means the candidate is faster. These are small effects: the 60 identical-baseline control +cells have a 95th percentile multiplicative distance from parity of 1.0206. Within-cell paired +bootstrap intervals exclude parity in the faster direction for 19 cases and in the slower direction +for two; they are not corrected for multiple comparisons and do not establish independent-host +reproducibility. All cells and intervals are retained in the [result data](lazy-content-state-20261107.json). + +| Task | Files or members | Elapsed change | Total CPU change | Peak RSS change | +| :------------------------- | ---------------: | -------------: | ---------------: | --------------: | +| Exact file listing | 100,000 | -0.67% | -0.74% | +0.84% | +| Native-case name filtering | 100,000 | -0.84% | -0.92% | +0.85% | +| Metadata and UTC date | 100,000 | +0.19% | +0.20% | +0.65% | +| Content regex | 100,000 | -0.24% | -0.16% | +0.67% | +| TAR member filtering | 10,000 | -0.43% | -0.33% | +0.98% | + +At 10,000 files, listing and native-case filtering improve by 1.33% and 1.53% respectively. +Several 100-file/member cases improve by about 1-2%. Individual counterexamples remain visible: +deep 10,000-file listing with three CPUs is 2.31% slower, and broad 100,000-file metadata output +with one CPU is 0.49% slower in this population. A separate targeted repeat covers both, plus six +predeclared listing, name, content, archive and size controls. + +That targeted repeat completed all 16 candidate/control cells and 1,344 validated invocations. +The deep-listing regression did not repeat: its candidate/baseline ratio was 0.9966, with a paired +interval spanning parity. The metadata counterexample did repeat at 1.0050. Broad 100,000-file +listing was 0.9895 (about 1.05% faster), compared with 0.9904 in the original population; native +name filtering was 0.9901. Broad content regex was 0.9955. The small-case intervals still span +parity. These selected follow-up cases are retained separately and are not substitutes for the +full population or proof of a universal improvement. + +## Instruction counts + +After timing collection, `perf stat` counted user-space instructions in seven runs of each retained +binary per selected case. These diagnostic invocations write to `/dev/null` and are excluded from +timing results. Output is checked independently before counting. The counters show reduced work +even where elapsed differences are small or inconclusive. + +| Case, one allowed CPU | Baseline instructions | Candidate instructions | Change | +| :--------------------------------- | --------------------: | ---------------------: | -----: | +| Broad listing, 100 files | 1,911,425 | 1,904,808 | -0.35% | +| Broad listing, 10,000 files | 25,487,490 | 24,827,442 | -2.59% | +| Broad listing, 100,000 files | 239,807,162 | 233,207,020 | -2.75% | +| Deep listing, 100,000 files | 252,332,090 | 245,730,529 | -2.62% | +| Broad metadata/date, 100,000 files | 594,265,420 | 589,065,424 | -0.88% | +| Broad regex, 100,000 files | 737,765,795 | 735,366,924 | -0.33% | +| Broad TAR, 10,000 members | 148,481,524 | 147,952,428 | -0.36% | + +Broad listing saves approximately 66 user-space instructions per file. This is direct evidence of +reduced work in the production binary, although it does not imply a 2.75% elapsed improvement. +The remaining evaluation, traversal, formatting and kernel work is unchanged by this patch. + +## Validation and retained evidence + +- Five focused test targets pass on macOS and Linux: snapshot, evaluator, parallel matching, + whole-run behavior and hash patterns. The macOS run contains 1,006 passing test cases. +- New snapshot tests cover unengaged copies/moves, repeated invalidation, replacement of active + and inactive caches, and empty derived-value transfers. Existing tests cover cached errors, + stable digest views, binary content and requested derived-cache transfers. +- Independent raw-sample replay checks all 1,440 exported values and 480 unavailable positions + for the candidate/control population; maximum arithmetic difference is 1.12e-16. + The targeted repeat adds 192 checked values and 1,248 genuinely unavailable positions. +- Source bundles, production executables, build/link evidence, raw rounds, host observations, + configuration reconciliation, construction assembly and instruction counters are retained under + `/home/marcus/Documents/xff-chart-campaign-20261107/lazy-content` on drogon. A verified local + copy lives under the original checkout's `bazel-extended-history-20261107/lazy-content` directory. +- The historical measurement population and its production binaries remain unchanged. macOS + whole-command speed has not been measured for this candidate. The timing suite exercises active + cache reads through regex matching, but does not qualify hash-heavy, similarity or diff workloads. diff --git a/docs/design-expression-program.md b/docs/design-expression-program.md index b175f52fe68..99f8ce1cb15 100644 --- a/docs/design-expression-program.md +++ b/docs/design-expression-program.md @@ -775,6 +775,31 @@ batches can return to the coordinator. Capture state stays in each evaluation co worker object may be evaluated concurrently with itself. Plans and source expressions outlive workers; moving a plan preserves its backing storage. +Prepared evaluation selects compact boolean recursion when the entry has neither a fuzzy-score +observer nor deferred evaluation state. Each recursive result then carries only truth and an +unknown/error flag; score and waiting-node storage is constructed once for the public result. +The predicate wrapper remains shared with general evaluation, including metadata observations, +dry-run previews, cache invalidation and output errors. Scoring or deferred contexts retain the +general evaluator. This selection preserves source order and every boolean operator's +short-circuit behavior; it performs no expression rewriting. + +FS-native glob matching uses an optional per-entry case resolver when the backend cannot promise +uniform case sensitivity. Exact and folded glob answers are compared before observing metadata: +if they agree, the filesystem cannot change the result. If they differ, the resolver loads the +entry's metadata and consults the existing device case cache. Negated character classes can lose +matches under folding, so an exact match alone is not sufficient to skip resolution. Required +metadata failures remain unknown results and cannot become matches through negation. Explicit +case folding bypasses the resolver; fuzzy matching resolves native case when reached. Deferred +entries retain their existing complete-metadata replay path. This does not infer a directory's +case rule for its children or assume a root's case rule applies across mount boundaries. + +Explicit `-print` and `-print0` actions borrow one coordinator-owned raw record buffer across +entries and deferred replay. The action chooses its own terminator independently of the implicit +listing format, and each sink still receives one complete record per action. Parallel filter +results emit through the coordinator and use the same buffer. Direct evaluator callers without +this scratch retain local record construction; oversized records release retained storage after +emission according to the renderer's existing bound. + The driver avoids preparation for unused parallel paths and shares preparation when the serial and pooled expressions are the same source node. A split filter/output expression retains its own preparation because each side has a different root. Deferred replay continues through the serial diff --git a/docs/design-parallel.md b/docs/design-parallel.md index c252dc38971..d1116888551 100644 --- a/docs/design-parallel.md +++ b/docs/design-parallel.md @@ -68,8 +68,11 @@ A bounded directory-read worker pool with a single coordinator: does not disable host-file parallelism: mounted/archive-member entries flush pending host results and use the serial evaluator. Both paths keep the same VFS and safety preflight. - Workers own each entry's content snapshot and rendered output. Predicates and match output reuse - that snapshot; source bytes are released when evaluation finishes. When templates or histograms - request hashes or line counts, selected workers derive those values from bytes already loaded and + that snapshot; source bytes are released when evaluation finishes. A snapshot reserves inline + cache storage but constructs its cache state only when a content consumer uses it. The + [lazy-state measurements](benchmarks/lazy-content-state-20261107.md) record the size/performance + tradeoff. When templates or histograms request hashes or line counts, selected workers derive + those values from bytes already loaded and move only requested caches to the ordered coordinator. A separate result-indexed vector exists only when values are requested; raw content never crosses this boundary. Streaming sources without loaded snapshots and result-limited listings keep lazy coordinator reads. The batch retains rendered diff --git a/release-site.json b/release-site.json index b70355fb84c..db089aaf7a0 100644 --- a/release-site.json +++ b/release-site.json @@ -142,7 +142,11 @@ "docs/benchmarks/queued-read-cancellation-20261107.md": "docs/benchmarks/queued-read-cancellation-20261107.html", "docs/benchmarks/archive-btree-historical-decision-20261107.md": "docs/benchmarks/archive-btree-historical-decision-20261107.html", "docs/benchmarks/compiled-field-stat-demand-20261107.md": "docs/benchmarks/compiled-field-stat-demand-20261107.html", - "docs/benchmarks/unchanged-site-payloads-20261107.md": "docs/benchmarks/unchanged-site-payloads-20261107.html" + "docs/benchmarks/unchanged-site-payloads-20261107.md": "docs/benchmarks/unchanged-site-payloads-20261107.html", + "docs/benchmark-chart-sensitivity-audit.md": "docs/benchmark-chart-sensitivity-audit.html", + "docs/benchmark-extended-history-campaign.md": "docs/benchmark-extended-history-campaign.html", + "docs/benchmarks/find-listing-optimization-20261107.md": "docs/benchmarks/find-listing-optimization-20261107.html", + "docs/benchmarks/lazy-content-state-20261107.md": "docs/benchmarks/lazy-content-state-20261107.html" }, "generated_html": { "XFF.md": { @@ -172,6 +176,14 @@ "docs/benchmarks/queued-read-cancellation-20261107.json.gz": "docs/benchmarks/queued-read-cancellation-20261107.json.gz", "docs/benchmarks/archive-btree-historical-decision-20261107.json.gz": "docs/benchmarks/archive-btree-historical-decision-20261107.json.gz", "docs/benchmarks/compiled-field-stat-demand-20261107.json.gz": "docs/benchmarks/compiled-field-stat-demand-20261107.json.gz", - "docs/benchmarks/unchanged-site-payloads-20261107.json.gz": "docs/benchmarks/unchanged-site-payloads-20261107.json.gz" + "docs/benchmarks/unchanged-site-payloads-20261107.json.gz": "docs/benchmarks/unchanged-site-payloads-20261107.json.gz", + "docs/benchmarks/chart-sensitivity-audit-20261107.json": "docs/benchmarks/chart-sensitivity-audit-20261107.json", + "docs/benchmarks/extended-history-builds-20261107.json": "docs/benchmarks/extended-history-builds-20261107.json", + "docs/benchmarks/extended-history-complete-audit-20261107.json": "docs/benchmarks/extended-history-complete-audit-20261107.json", + "docs/benchmarks/extended-history-results-20261107.json": "docs/benchmarks/extended-history-results-20261107.json", + "docs/benchmarks/extended-history-revisions-20261107.json": "docs/benchmarks/extended-history-revisions-20261107.json", + "docs/benchmarks/extended-history-viewer-check-20261107.json": "docs/benchmarks/extended-history-viewer-check-20261107.json", + "docs/benchmarks/find-listing-optimization-20261107.json": "docs/benchmarks/find-listing-optimization-20261107.json", + "docs/benchmarks/lazy-content-state-20261107.json": "docs/benchmarks/lazy-content-state-20261107.json" } } diff --git a/tools/BUILD.bazel b/tools/BUILD.bazel index 2ac6847336d..01184ba30da 100644 --- a/tools/BUILD.bazel +++ b/tools/BUILD.bazel @@ -922,6 +922,10 @@ test_suite( ":benchmark_campaign_test", ":benchmark_compare_test", ":benchmark_datasets_test", + ":benchmark_extended_build_test", + ":benchmark_extended_history_test", + ":benchmark_extended_report_test", + ":benchmark_extended_test", ":benchmark_fixture_test", ":benchmark_history_test", ":benchmark_landscape_test", @@ -1168,6 +1172,94 @@ py_library( ], ) +py_library( + name = "benchmark_extended_lib", + srcs = ["benchmark_extended.py"], + imports = ["."], +) + +py_test( + name = "benchmark_extended_test", + size = "small", + srcs = ["benchmark_extended_test.py"], + deps = [":benchmark_extended_lib"], +) + +py_library( + name = "benchmark_extended_build_lib", + srcs = ["benchmark_extended_build.py"], + imports = ["."], +) + +py_binary( + name = "benchmark_extended_build", + srcs = ["benchmark_extended_build.py"], +) + +py_test( + name = "benchmark_extended_build_test", + size = "small", + srcs = ["benchmark_extended_build_test.py"], + deps = [":benchmark_extended_build_lib"], +) + +py_library( + name = "benchmark_extended_history_lib", + srcs = ["benchmark_extended_history.py"], + imports = ["."], + deps = [ + ":benchmark_extended_lib", + ":process_resources_lib", + ], +) + +py_binary( + name = "benchmark_extended_history", + srcs = ["benchmark_extended_history.py"], + deps = [ + ":benchmark_extended_lib", + ":process_resources_lib", + ], +) + +py_test( + name = "benchmark_extended_history_test", + size = "small", + srcs = ["benchmark_extended_history_test.py"], + deps = [ + ":benchmark_extended_history_lib", + ":benchmark_extended_lib", + ], +) + +py_library( + name = "benchmark_extended_report_lib", + srcs = ["benchmark_extended_report.py"], + imports = ["."], + deps = [ + ":benchmark_extended_lib", + ":benchmark_landscape_lib", + ":benchmark_matrix_lib", + ], +) + +py_binary( + name = "benchmark_extended_report", + srcs = ["benchmark_extended_report.py"], + deps = [ + ":benchmark_extended_lib", + ":benchmark_landscape_lib", + ":benchmark_matrix_lib", + ], +) + +py_test( + name = "benchmark_extended_report_test", + size = "small", + srcs = ["benchmark_extended_report_test.py"], + deps = [":benchmark_extended_report_lib"], +) + py_binary( name = "benchmark_compare", srcs = ["benchmark_compare.py"], diff --git a/tools/benchmark_extended.py b/tools/benchmark_extended.py new file mode 100644 index 00000000000..0970cadb1f9 --- /dev/null +++ b/tools/benchmark_extended.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Versioned production workloads for the extended benchmark qualification campaign.""" + +from collections import Counter +from dataclasses import dataclass +import hashlib +import io +import json +import os +from pathlib import Path +import tarfile + + +RECIPE = 'extended-production-v1' +MTIME = 1577923200 # 2020-01-02 00:00:00 UTC. +PATTERN = r'(ERROR|WARN) service=api_[0-9]+ status=5[0-9]{2}' +TASKS = ('files-exact', 'name-native', 'metadata-time', 'content-regex', 'archive-tar') + + +@dataclass(frozen=True) +class Case: + name: str + shape: str + files: int + cpus: int + + def __post_init__(self): + if (self.name not in TASKS or self.shape not in ('broad', 'deep') or + type(self.files) is not int or self.files < 1 or type(self.cpus) is not int or self.cpus < 1): + raise ValueError('invalid extended case') + + @property + def key(self): + return f'{self.name}/{self.shape}/{self.files}/{self.cpus}' + + +def cases(): + """Include large traversal cells without making every archive trial a 100k scan.""" + return [Case(name, shape, count, cpus) for name in TASKS + for shape in ('broad', 'deep') + for count in ((100, 1000, 10000) if name == 'archive-tar' else (100, 10000, 100000)) + for cpus in (1, 3)] + + +def entries(shape, count, archive=False): + if shape not in ('broad', 'deep') or count < 1: + raise ValueError('invalid fixture dimensions') + for index in range(count): + if archive: + directory = f'd{index // 100:04}/' + if shape == 'deep': + directory = 'level/' * (index // 100 % 8 + 1) + directory + else: + directory = '' if shape == 'broad' else 'level/' * (index % 40 + 1) + name = directory + f'item_{index:06}.' + ('txt' if index % 2 == 0 else 'log') + matched = index % 3 == 0 + size = 8192 if index % 50 == 0 else 256 + tail = (b'ERROR service=api_12 status=503\n' if matched else + b'ERROR service=api_12 status=200\n') + data = b'x' * (size - len(tail) - 1) + b'\n' + tail + yield name, data, matched + + +def fixture_identity(shape, count, archive=False): + digest = hashlib.sha256() + digest.update(f'{RECIPE}/{shape}/{count}/{archive}/{MTIME}'.encode()) + for name, data, _ in entries(shape, count, archive): + digest.update(name.encode() + b'\0' + data + b'\0') + return digest.hexdigest() + + +def prepare(parent, selected_cases=None): + """Create only inside a new owned directory; callers verify tmpfs before collection.""" + parent = Path(parent) + parent.mkdir(exist_ok=False) + (parent / 'empty').write_bytes(b'') + (parent / 'home').mkdir() + specifications = sorted({(case.shape, case.files, case.name == 'archive-tar') + for case in (cases() if selected_cases is None else selected_cases)}) + records = [] + for shape, count, archive in specifications: + root = parent / ('archive' if archive else 'native') / shape / str(count) + root.mkdir(parents=True) + if archive: + with tarfile.open(root / 'fixture.tar', 'w', format=tarfile.USTAR_FORMAT) as handle: + for name, data, _ in entries(shape, count, True): + member = tarfile.TarInfo(name) + member.size, member.mtime, member.mode = len(data), MTIME, 0o644 + member.uid = member.gid = 0 + handle.addfile(member, io.BytesIO(data)) + content_hash = hashlib.sha256((root / 'fixture.tar').read_bytes()).hexdigest() + else: + for name, data, _ in entries(shape, count): + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + target.chmod(0o644) + os.utime(target, (MTIME, MTIME)) + content_hash = None + records.append({'shape': shape, 'files': count, 'archive': archive, + 'fixture_identity': fixture_identity(shape, count, archive), + 'archive_sha256': content_hash}) + (parent / 'manifest.json').write_text(json.dumps({'recipe': RECIPE, 'fixtures': records}, indent=2) + '\n') + return records + + +def commands(case, parent, binary, tools): + parent = Path(parent) + root = parent / ('archive' if case.name == 'archive-tar' else 'native') / case.shape / str(case.files) + base = [str(binary), '--no-config', '--no-pager', '--color=never', '--sort=none', + '--gitignore=off', '--hidden', f'--jobs={case.cpus}'] + find = [tools['find'], '-P', str(root), '-type', 'f'] + if case.name == 'files-exact': + return {'xff': [*base, '--exact', '.', '-type', 'f', '-print0'], + 'find': [tools['find'], '-P', '.', '-type', 'f', '-print0']}, root, b'\0' + if case.name == 'name-native': + return {'xff': [*base, str(root), '-type', 'f', '-name', '*.txt', '-print0'], + 'find': [*find, '-name', '*.txt', '-print0']}, root, b'\0' + if case.name == 'metadata-time': + template = r'%p\t%s\t%TY-%Tm-%Td\0' + return {'xff': [*base, '--exact', '--timezone=UTC', str(root), '-type', 'f', + '-name', '*.txt', '-size', '+128c', '-printf', template], + 'find': [*find, '-name', '*.txt', '-size', '+128c', '-printf', template]}, root, b'\0' + if case.name == 'content-regex': + return {'xff': [*base, '--exact', '--case=sensitive', '--regextype=RE2', str(root), + '-type', 'f', '-name', '*.txt', '-rxc', PATTERN, '-print0'], + 'rg': [tools['rg'], '--no-config', '--hidden', '--no-ignore', '--color=never', + '--case-sensitive', '--text', f'--threads={case.cpus}', '-g', '*.txt', + '--files-with-matches', '--null', '-e', PATTERN, str(root)]}, root, b'\0' + if case.name == 'archive-tar': + return {'xff': [*base, '--exact', '--archive=roots', '--archive-separator=/', + 'fixture.tar', '-type', 'f', '-name', '*.txt', '-print'], + 'tar': [tools['tar'], '-tf', 'fixture.tar', '--wildcards', '*.txt', + '--transform=s,^,fixture.tar/,', '--show-transformed-names']}, root, b'\n' + raise ValueError('unknown extended task: ' + case.name) + + +def expected(case, parent): + root = Path(parent) / 'native' / case.shape / str(case.files) + result = [] + for name, data, matched in entries(case.shape, case.files, case.name == 'archive-tar'): + if case.name != 'files-exact' and not name.endswith('.txt'): + continue + if case.name == 'content-regex' and not matched: + continue + if case.name == 'archive-tar': + value = 'fixture.tar/' + name + elif case.name == 'files-exact': + value = './' + name + elif case.name == 'metadata-time': + value = f'{root / name}\t{len(data)}\t2020-01-02' + else: + value = str(root / name) + result.append(value.encode()) + return result + + +def validate(sample, wanted, separator): + if sample['exit_codes'] != [0] or sample['stderr_bytes'] or sample['stderr']: + raise ValueError(f'command failed: exit={sample["exit_codes"]}; ' + f'stderr={sample["stderr"][:2000]!r}') + output = sample['output'] + if output and not output.endswith(separator): + raise ValueError('output lacks its final record separator') + actual = output.removesuffix(separator).split(separator) if output else [] + if Counter(actual) != Counter(wanted): + missing = list((Counter(wanted) - Counter(actual)).items())[:3] + extra = list((Counter(actual) - Counter(wanted)).items())[:3] + raise ValueError(f'output oracle mismatch; missing={missing!r}; extra={extra!r}') + if sample['stdout_bytes'] != len(output): + raise ValueError('output byte accounting mismatch') + return hashlib.sha256(output).hexdigest() + + +def verify(parent, selected_cases=None): + """Re-read fixture contents and metadata before accepting or resuming measurements.""" + parent = Path(parent) + specifications = {(case.shape, case.files, case.name == 'archive-tar') + for case in (cases() if selected_cases is None else selected_cases)} + manifest = json.loads((parent / 'manifest.json').read_text()) + if manifest['recipe'] != RECIPE or len(manifest['fixtures']) != len(specifications): + raise ValueError('fixture manifest changed') + for record in manifest['fixtures']: + shape, count, archive = record['shape'], record['files'], record['archive'] + if (shape, count, archive) not in specifications: + raise ValueError('unexpected fixture specification') + root = parent / ('archive' if archive else 'native') / shape / str(count) + if record['fixture_identity'] != fixture_identity(shape, count, archive): + raise ValueError('fixture recipe identity changed') + if archive: + if hashlib.sha256((root / 'fixture.tar').read_bytes()).hexdigest() != record['archive_sha256']: + raise ValueError('archive fixture changed') + continue + paths = set() + for name, data, _ in entries(shape, count): + target = root / name + stat = target.stat() + if target.is_symlink() or target.read_bytes() != data or stat.st_mtime != MTIME or stat.st_mode & 0o777 != 0o644: + raise ValueError('native fixture changed: ' + str(target)) + paths.add(name) + actual = {str(p.relative_to(root)) for p in root.rglob('*') if not p.is_dir()} + if actual != paths: + raise ValueError('native fixture population changed') + return manifest diff --git a/tools/benchmark_extended_build.py b/tools/benchmark_extended_build.py new file mode 100644 index 00000000000..d9e5e535e7c --- /dev/null +++ b/tools/benchmark_extended_build.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Freeze historical full production executables before extended measurements.""" + +import argparse +from datetime import datetime, timezone +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import time + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def write(path, value): + temporary = path.with_suffix(path.suffix + '.tmp') + temporary.write_text(json.dumps(value, indent=2) + '\n') + temporary.replace(path) + + +def git(checkout, *args): + return subprocess.check_output(['git', '-C', str(checkout), *args], text=True).strip() + + +def clean_source(checkout, sha): + if git(checkout, 'rev-parse', 'HEAD') != sha or git(checkout, 'status', '--porcelain'): + raise ValueError('historical checkout must exactly match its clean revision') + if (checkout / '.bazelrc.user').exists(): + raise ValueError('workspace Bazel override is forbidden') + return {'revision': sha, 'tree': git(checkout, 'rev-parse', 'HEAD^{tree}'), 'clean': True} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--root', type=Path, required=True) + parser.add_argument('--revisions', type=Path, required=True) + parser.add_argument('--disk-cache', type=Path, required=True) + parser.add_argument('--jobs', type=int, default=6) + parser.add_argument('--build-library-path', type=Path) + args = parser.parse_args() + root, checkout = args.root.resolve(), args.root.resolve() / 'checkout' + revisions = json.loads(args.revisions.read_text()) + policy = {'revisions': revisions, 'target': '//xff/cli:xff_full', + 'configs': ['clang_release', 'xff_full'], 'driver_sha256': digest(Path(__file__)), + 'startup_flags': ['--nosystem_rc', '--nohome_rc'], 'jobs': args.jobs, + 'disk_cache': str(args.disk_cache.resolve())} + if args.build_library_path: + library_path = args.build_library_path.resolve(strict=True) + policy['build_library_path'] = str(library_path) + policy['build_libraries'] = {p.name: digest(p) for p in sorted(library_path.iterdir()) if p.is_file()} + contract_path = root / 'build-contract.json' + if contract_path.exists() and json.loads(contract_path.read_text()) != policy: + raise ValueError('cannot resume a changed build contract') + write(contract_path, policy) + status_path = root / 'build-status.json' + status = json.loads(status_path.read_text()) if status_path.exists() else {} + # Endpoints first permit functional qualification while the remaining builds run. + order = [revisions[-1], *revisions[:-1]] + for index, revision in enumerate(order, 1): + sha = revision['sha'] + directory = root / 'binaries' / sha + directory.mkdir(parents=True, exist_ok=True) + identity, executable = directory / 'build.json', directory / 'xff_full' + if identity.exists(): + saved = json.loads(identity.read_text()) + if saved['source']['revision'] != sha or saved['sha256'] != digest(executable): + raise ValueError('retained executable mismatch: ' + sha) + status[sha] = {'status': 'built', 'sha256': saved['sha256']} + write(status_path, status) + continue + started = time.monotonic() + print(f'BUILD {index}/{len(order)} PR #{revision["pr"]} {sha}', flush=True) + status[sha] = {'status': 'building', 'started_at': datetime.now(timezone.utc).isoformat()} + write(status_path, status) + try: + subprocess.run(['git', '-C', str(checkout), 'checkout', '--detach', sha], check=True) + source = clean_source(checkout, sha) + bazel = ['bazel', *policy['startup_flags']] + options = ['--config=clang_release', '--config=xff_full', + '--disk_cache=' + str(args.disk_cache.resolve()), '--jobs=' + str(args.jobs)] + if args.build_library_path: + options.append('--action_env=LD_LIBRARY_PATH=' + str(args.build_library_path.resolve())) + command = [*bazel, 'build', '//xff/cli:xff_full', *options] + with (directory / 'build.log').open('w') as log: + subprocess.run(command, cwd=checkout, stdout=log, stderr=subprocess.STDOUT, check=True) + query = [*bazel, 'cquery', 'config(//xff/cli:xff_full, target)', *options, + '--output=starlark', '--starlark:expr=target.files_to_run.executable.path'] + artifact = subprocess.check_output(query, cwd=checkout, stderr=log, text=True).strip() + if not artifact or len(artifact.splitlines()) != 1: + raise ValueError('configured executable query is ambiguous') + if clean_source(checkout, sha) != source: + raise ValueError('source identity changed during build') + built = checkout / artifact + binary_hash = digest(built) + shutil.copy2(built, executable) + if digest(executable) != binary_hash: + raise ValueError('frozen executable copy mismatch') + # Link actions record the actual production LTO command for this revision. + with (directory / 'link-actions.json').open('w') as actions: + subprocess.run([*bazel, 'aquery', 'mnemonic("CppLink", //xff/cli:xff_full)', + *options, '--output=jsonproto'], cwd=checkout, stdout=actions, + stderr=log, check=True) + saved = {'source': source, 'sha256': binary_hash, 'bytes': executable.stat().st_size, + 'command': command, 'query': query, 'artifact': artifact, + 'elapsed_seconds': time.monotonic() - started, + 'completed_at': datetime.now(timezone.utc).isoformat(), + 'configuration': {name: digest(checkout / name) for name in + ('.bazelrc', '.bazelversion', 'MODULE.bazel', 'MODULE.bazel.lock', + 'bazelmod/llvm.MODULE.bazel') if (checkout / name).is_file()}} + write(identity, saved) + status[sha] = {'status': 'built', 'sha256': binary_hash, 'seconds': saved['elapsed_seconds']} + print(f'BUILT {index}/{len(order)} {sha[:10]} {binary_hash} {saved["elapsed_seconds"]:.1f}s', flush=True) + except (subprocess.CalledProcessError, ValueError, OSError) as error: + status[sha] = {'status': 'build-failed', 'error': str(error), + 'seconds': time.monotonic() - started} + print(f'FAILED {sha}: {error}', flush=True) + write(status_path, status) + raise + write(status_path, status) + print('BUILD PHASE COMPLETE', json.dumps({state: sum(v['status'] == state for v in status.values()) + for state in sorted({v['status'] for v in status.values()})}), flush=True) + + +if __name__ == '__main__': + main() diff --git a/tools/benchmark_extended_build_test.py b/tools/benchmark_extended_build_test.py new file mode 100644 index 00000000000..491b0dea477 --- /dev/null +++ b/tools/benchmark_extended_build_test.py @@ -0,0 +1,44 @@ +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Keep historical source and binary provenance fail closed without invoking Bazel.""" + +from pathlib import Path +import tempfile +import unittest +from unittest import mock + +import benchmark_extended_build as build + + +class BenchmarkExtendedBuildTest(unittest.TestCase): + def test_clean_source_records_exact_revision_and_tree(self): + with tempfile.TemporaryDirectory() as temporary: + with mock.patch.object(build, 'git', side_effect=['revision', '', 'tree']) as git: + self.assertEqual(build.clean_source(Path(temporary), 'revision'), + {'revision': 'revision', 'tree': 'tree', 'clean': True}) + self.assertEqual([call.args[1:] for call in git.call_args_list], + [('rev-parse', 'HEAD'), ('status', '--porcelain'), ('rev-parse', 'HEAD^{tree}')]) + + def test_dirty_or_wrong_checkout_and_local_bazel_override_are_rejected(self): + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) + for answers in (['wrong'], ['revision', ' M source.cc']): + with mock.patch.object(build, 'git', side_effect=answers), self.assertRaises(ValueError): + build.clean_source(root, 'revision') + (root / '.bazelrc.user').touch() + with mock.patch.object(build, 'git', side_effect=['revision', '']), self.assertRaisesRegex(ValueError, 'override'): + build.clean_source(root, 'revision') + + def test_identity_hash_changes_with_artifact_contents(self): + with tempfile.TemporaryDirectory() as temporary: + path = Path(temporary) / 'xff' + path.write_bytes(b'old') + old = build.digest(path) + path.write_bytes(b'new') + self.assertNotEqual(build.digest(path), old) + build.write(Path(temporary) / 'identity.json', {'hash': old}) + self.assertFalse((Path(temporary) / 'identity.json.tmp').exists()) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/benchmark_extended_history.py b/tools/benchmark_extended_history.py new file mode 100644 index 00000000000..27a8f35b3ac --- /dev/null +++ b/tools/benchmark_extended_history.py @@ -0,0 +1,283 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Measure frozen historical executables against a current anchor and reference tools. + +Linux qualification only. This separate versioned campaign never appends incompatible +workloads to the published core dataset. Each command uses the existing native resource +launcher; fresh fork workers provide timeout and affinity isolation. Validation and JSON +serialization occur after the measured interval. All raw timing samples are retained. +""" + +import argparse +from dataclasses import asdict +from datetime import datetime, timezone +import fcntl +import gzip +import hashlib +import json +import multiprocessing +import os +from pathlib import Path +import platform +import random +import shutil +import signal +import subprocess +import sys +import time + +import benchmark_extended as suite +import process_resources + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def write(path, value): + temporary = path.with_suffix(path.suffix + '.tmp') + temporary.write_text(json.dumps(value, indent=2) + '\n') + temporary.replace(path) + + +def freeze(path, value): + if path.exists() and json.loads(path.read_text()) != value: + raise ValueError('cannot resume changed contract: ' + str(path)) + write(path, value) + + +def cpu_allocation(count): + """Prefer separate physical cores over sibling hardware threads.""" + cores = {} + for cpu in sorted(os.sched_getaffinity(0)): + topology = Path(f'/sys/devices/system/cpu/cpu{cpu}/topology') + key = ((topology / 'physical_package_id').read_text(), (topology / 'core_id').read_text()) + cores.setdefault(key, cpu) + result = list(cores.values())[:count] + if len(result) != count: + raise ValueError('not enough allowed physical cores') + return result + + +def worker(connection, spec, wanted, separator, failure_path): + """Fresh worker; no Python process is included in command resource accounting.""" + sample = None + try: + os.setsid() + os.sched_setaffinity(0, spec['affinity']) + with open(spec['stdin'], 'rb') as source: + sample = process_resources.measure_pipeline( + [spec['command']], source=source, cwd=spec['cwd'], environment=spec['environment'], + launcher=spec['launcher'], stderr_limit=8192) + output_hash = suite.validate(sample, wanted, separator) + sample.pop('output') + sample.update(stdout_sha256=output_hash, validated_records=len(wanted)) + connection.send({'sample': sample}) + except BaseException as error: + if sample is not None and 'output' in sample: + with gzip.open(failure_path, 'wb') as output: + output.write(sample.pop('output')) + connection.send({'error': repr(error), 'sample': sample}) + finally: + connection.close() + + +def invoke(spec, wanted, separator, failure_path, timeout=120): + context = multiprocessing.get_context('fork') + receiver, sender = context.Pipe(duplex=False) + child = context.Process(target=worker, args=(sender, spec, wanted, separator, failure_path)) + child.start() + sender.close() + try: + if not receiver.poll(timeout): + # setsid precedes launch; kill only our worker's own process group. + if child.is_alive() and os.getpgid(child.pid) == child.pid: + os.killpg(child.pid, signal.SIGKILL) + else: + child.kill() + raise ValueError(f'measurement exceeded {timeout} seconds') + response = receiver.recv() + if 'error' in response: + raise ValueError(str(response)) + return response['sample'] + finally: + receiver.close() + child.join(timeout=5) + if child.is_alive(): + child.kill() + child.join() + + +def host_context(): + return {'utc': datetime.now(timezone.utc).isoformat(), 'loadavg': os.getloadavg(), + 'meminfo': Path('/proc/meminfo').read_text(), + 'cpu_stat': Path('/proc/stat').read_text(), + 'pressure': {name: (Path('/proc/pressure') / name).read_text() + for name in ('cpu', 'memory', 'io')}} + + +def round_order(labels, case_index, repetition): + offset = (case_index + repetition) % len(labels) + return labels[offset:] + labels[:offset] + + +def collect_cell(case, revision, anchor, root, fixture, tools, launcher, affinity, index, repetitions): + directory = root / 'cells' / revision['sha'] / case.key + directory.mkdir(parents=True, exist_ok=True) + completed = directory / 'complete.json' + if completed.exists(): + return json.loads(completed.read_text()) + attempts = directory / 'attempts' + attempts.mkdir(exist_ok=True) + attempt = attempts / str(len(list(attempts.iterdir())) + 1) + attempt.mkdir() + wanted = suite.expected(case, fixture) + commands, cwd, separator = suite.commands(case, fixture, revision['binary'], tools) + anchor_commands, _, _ = suite.commands(case, fixture, anchor['binary'], tools) + commands['anchor'] = anchor_commands['xff'] + labels = list(commands) + environment = {'PATH': '/usr/bin:/bin', 'HOME': str(fixture / 'home'), 'LC_ALL': 'C', 'TZ': 'UTC'} + row = {'case': asdict(case), 'revision': revision, 'anchor': anchor, + 'expected_records': len(wanted), 'expected_sha256': hashlib.sha256(b'\0'.join(sorted(wanted))).hexdigest(), + 'commands': commands, 'cwd': str(cwd), 'affinity': affinity[:case.cpus], 'environment': environment, + 'before': host_context(), 'samples': [], 'attempt': str(attempt)} + write(attempt / 'start.json', row) + try: + with (attempt / 'samples.jsonl').open('x') as raw: + for repetition in range(repetitions + 1): + for label in round_order(labels, index, repetition): + spec = {'command': commands[label], 'cwd': str(cwd), 'environment': environment, + 'stdin': str(fixture / 'empty'), 'launcher': launcher, + 'affinity': affinity[:case.cpus]} + record = {'label': label, 'round': repetition, + 'phase': 'warmup' if repetition == 0 else 'measured', + 'utc': datetime.now(timezone.utc).isoformat()} + record.update(invoke(spec, wanted, separator, attempt / 'failed-output.gz')) + row['samples'].append(record) + raw.write(json.dumps(record) + '\n') + raw.flush() + row['after'] = host_context() + write(completed, row) + except BaseException as error: + write(attempt / 'failure.json', {'error': repr(error), 'context': host_context()}) + raise + return row + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--root', type=Path, required=True) + parser.add_argument('--build-root', type=Path, required=True) + parser.add_argument('--revisions', type=Path, required=True) + parser.add_argument('--fixture', type=Path, required=True) + parser.add_argument('--resource-launcher', type=Path, required=True) + parser.add_argument('--cases', type=Path, help='Optional frozen JSON list of Case records for qualification') + parser.add_argument('--repetitions', type=int, default=9) + parser.add_argument('--keep', type=int, default=7) + parser.add_argument('--limit', type=int, help='Stop cleanly after this many new cells; contract is unchanged') + args = parser.parse_args() + if sys.platform != 'linux' or not 1 <= args.keep <= args.repetitions: + parser.error('requires Linux and 1 <= keep <= repetitions') + root, fixture, builds = args.root.resolve(), args.fixture.resolve(), args.build_root.resolve() + root.mkdir(parents=True, exist_ok=True) + collection_lock = (root / 'collection.lock').open('a') + fcntl.flock(collection_lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + if (root / 'invalid.json').exists(): + raise ValueError('campaign identity changed previously; inspect invalid.json before starting a new campaign') + revisions = json.loads(args.revisions.read_text()) + cases = [suite.Case(**case) for case in json.loads(args.cases.read_text())] if args.cases else suite.cases() + if not revisions or not cases or len({r['sha'] for r in revisions}) != len(revisions) or len({c.key for c in cases}) != len(cases): + raise ValueError('empty or duplicate revisions/cases') + affinity = cpu_allocation(max(case.cpus for case in cases)) + # Collection requires already-frozen binaries. Build completion is checked by the operator; + # no compiler is invoked anywhere in this measurement driver. + for revision in revisions: + directory = builds / 'binaries' / revision['sha'] + identity = json.loads((directory / 'build.json').read_text()) + binary = directory / 'xff_full' + if identity['source']['revision'] != revision['sha'] or digest(binary) != identity['sha256']: + raise ValueError('binary/source identity mismatch') + actions = json.loads((directory / 'link-actions.json').read_text()) + links = [action['arguments'] for action in actions['actions'] + if identity['artifact'] in action.get('arguments', [])] + if len(links) != 1 or '-flto=thin' not in links[0]: + raise ValueError('production ThinLTO link evidence is missing: ' + revision['sha']) + revision.update(binary=str(binary), binary_sha256=identity['sha256'], build_sha256=digest(directory / 'build.json'), + link_actions_sha256=digest(directory / 'link-actions.json')) + anchor = revisions[-1] + tools = {} + for name in ('find', 'rg', 'tar'): + path = str(Path(shutil.which(name)).resolve(strict=True)) + tools[name] = {'path': path, 'sha256': digest(path), + 'version': subprocess.check_output([path, '--version'], text=True).strip()} + launcher = process_resources.launcher_identity(args.resource_launcher) + filesystem = subprocess.check_output(['findmnt', '-n', '-o', 'FSTYPE', '-T', str(fixture.parent)], text=True).strip() + if filesystem != 'tmpfs': + raise ValueError('fixtures must reside on tmpfs, found: ' + filesystem) + contract = {'recipe': suite.RECIPE, 'cases': [asdict(case) for case in cases], 'revisions': revisions, + 'repetitions': args.repetitions, 'keep': args.keep, 'estimator': 'mean-fastest', + 'warmup_rounds': 1, 'anchor': anchor, 'fixture': str(fixture), 'filesystem': filesystem, + 'tools': tools, 'launcher': launcher, 'affinity': affinity, 'platform': platform.platform(), + 'cpuinfo': Path('/proc/cpuinfo').read_text().split('\n\n')[0], + 'python': sys.version, 'drivers': {Path(module).name: digest(module) for module in + (__file__, suite.__file__, process_resources.__file__)}, + 'build_contract_sha256': digest(builds / 'build-contract.json'), + 'order': 'seed 20261107 shuffles revisions and cells; participant start rotates each round', + 'output_retention': 'all outputs checked; successful output hash/count retained; failing output gzip retained'} + # cpu MHz fluctuates: record it as context, never as a resume identity field. + contract['cpuinfo'] = '\n'.join(line for line in contract['cpuinfo'].splitlines() if not line.startswith('cpu MHz')) + freeze(root / 'contract.json', contract) + if not fixture.exists(): + suite.prepare(fixture, cases) + manifest = suite.verify(fixture, cases) + freeze(root / 'fixtures.json', manifest) + order = list(revisions) + random.Random(20261107).shuffle(order) + ordered_cases = list(cases) + random.Random(20261108).shuffle(ordered_cases) + progress = {'total': len(order) * len(cases), 'completed': 0, 'new_cells': 0, 'state': 'running'} + started = time.monotonic() + for revision in order: + for case in ordered_cases: + completed = root / 'cells' / revision['sha'] / case.key / 'complete.json' + existing = completed.exists() + try: + collect_cell(case, revision, anchor, root, fixture, {key: value['path'] for key, value in tools.items()}, + launcher['path'], affinity, progress['completed'], args.repetitions) + except BaseException as error: + progress.update(state='failed', error=repr(error), pr=revision['pr'], case=case.key) + write(root / 'progress.json', progress) + raise + progress['completed'] += 1 + if not existing: + progress['new_cells'] += 1 + progress.update(utc=datetime.now(timezone.utc).isoformat(), pr=revision['pr'], case=case.key, + session_seconds=time.monotonic() - started) + write(root / 'progress.json', progress) + print(f'CELL {progress["completed"]}/{progress["total"]} PR #{revision["pr"]} {case.key} ' + f'{progress["session_seconds"]:.1f}s session', flush=True) + if args.limit and progress['new_cells'] >= args.limit: + print('Requested cell limit reached; resume with the same contract.', flush=True) + return + for record in (revision, anchor): + if digest(record['binary']) != record['binary_sha256']: + write(root / 'invalid.json', {'reason': 'binary changed while collecting', 'revision': record['sha']}) + raise ValueError('binary changed while collecting') + try: + suite.verify(fixture, cases) + for tool in tools.values(): + if digest(tool['path']) != tool['sha256']: + raise ValueError('reference executable changed while collecting') + if process_resources.launcher_identity(launcher['path']) != launcher: + raise ValueError('resource launcher changed while collecting') + except BaseException as error: + write(root / 'invalid.json', {'reason': repr(error)}) + raise + progress.update(state='complete', utc=datetime.now(timezone.utc).isoformat()) + write(root / 'progress.json', progress) + print('MEASUREMENT PHASE COMPLETE', flush=True) + + +if __name__ == '__main__': + main() diff --git a/tools/benchmark_extended_history_test.py b/tools/benchmark_extended_history_test.py new file mode 100644 index 00000000000..7be1172caff --- /dev/null +++ b/tools/benchmark_extended_history_test.py @@ -0,0 +1,71 @@ +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Guard interleaving, frozen contracts, resume, and failed-output retention.""" + +import json +from pathlib import Path +import tempfile +import unittest +from unittest import mock + +import benchmark_extended as suite +import benchmark_extended_history as history + + +class BenchmarkExtendedHistoryTest(unittest.TestCase): + def test_each_participant_gets_each_order_position(self): + labels = ['xff', 'find', 'anchor'] + for case in range(3): + orders = [history.round_order(labels, case, repetition) for repetition in range(1, 10)] + for position in range(3): + self.assertEqual([order[position] for order in orders].count('xff'), 3) + self.assertEqual([order[position] for order in orders].count('find'), 3) + self.assertEqual([order[position] for order in orders].count('anchor'), 3) + + def test_resume_rejects_changed_contract(self): + with tempfile.TemporaryDirectory() as temporary: + path = Path(temporary) / 'contract.json' + history.freeze(path, {'sha': 'old', 'keep': 7}) + history.freeze(path, {'sha': 'old', 'keep': 7}) + with self.assertRaisesRegex(ValueError, 'changed contract'): + history.freeze(path, {'sha': 'new', 'keep': 7}) + self.assertEqual(json.loads(path.read_text()), {'sha': 'old', 'keep': 7}) + + def test_warmups_and_all_samples_are_retained_and_completed_cells_resume(self): + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) + case = suite.Case('files-exact', 'broad', 3, 1) + revision = {'sha': 'old', 'binary': '/old/xff'} + anchor = {'sha': 'new', 'binary': '/new/xff'} + sample = {'elapsed_seconds': .1, 'stdout_sha256': 'hash', 'validated_records': 3} + with mock.patch.object(history, 'invoke', return_value=sample) as invoke, \ + mock.patch.object(history, 'host_context', return_value={'utc': 'fixed'}): + args = (case, revision, anchor, root, root / 'fixture', {'find': '/bin/find'}, '/launcher', [0, 1, 2], 0, 3) + row = history.collect_cell(*args) + self.assertEqual(invoke.call_count, 12) + self.assertEqual(sum(s['phase'] == 'warmup' for s in row['samples']), 3) + self.assertEqual(sum(s['phase'] == 'measured' for s in row['samples']), 9) + self.assertEqual(row['commands']['xff'][0], '/old/xff') + self.assertEqual(row['commands']['anchor'][0], '/new/xff') + self.assertEqual(history.collect_cell(*args), row) + self.assertEqual(invoke.call_count, 12) + + def test_failed_attempt_never_becomes_a_completed_cell(self): + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) + case = suite.Case('files-exact', 'broad', 3, 1) + args = (case, {'sha': 'old', 'binary': '/old'}, {'sha': 'new', 'binary': '/new'}, + root, root / 'fixture', {'find': '/bin/find'}, '/launcher', [0], 0, 1) + with mock.patch.object(history, 'invoke', side_effect=ValueError('incorrect output')), \ + mock.patch.object(history, 'host_context', return_value={}): + for _ in range(2): + with self.assertRaisesRegex(ValueError, 'incorrect output'): + history.collect_cell(*args) + directory = root / 'cells/old' / case.key + self.assertFalse((directory / 'complete.json').exists()) + self.assertTrue((directory / 'attempts/1/failure.json').is_file()) + self.assertTrue((directory / 'attempts/2/failure.json').is_file()) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/benchmark_extended_report.py b/tools/benchmark_extended_report.py new file mode 100644 index 00000000000..3ef7607b75e --- /dev/null +++ b/tools/benchmark_extended_report.py @@ -0,0 +1,301 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Analyze every extended-history cell and export the existing 3D history viewer.""" + +import argparse +from collections import defaultdict +import csv +import hashlib +import html +import json +import math +from pathlib import Path +import random +import shutil +import statistics + +import benchmark_extended as suite +import benchmark_landscape as landscape +import benchmark_matrix as matrix + + +def revision_label(revision): + if revision['pr'] > 0: + return f'PR #{revision["pr"]}' + return 'Experiment ' + revision['sha'][:12] + + +def endpoint_summaries(rows, contract): + """Keep unmerged experiments distinct even when they share the PR-zero sentinel.""" + return {(str(revision['pr']) if revision['pr'] > 0 else revision['sha']): + [row for row in rows if row['sha'] == revision['sha']] + for revision in (contract['revisions'][0], contract['revisions'][-1])} + + +def mean_fastest(samples, keep): + values = [sample['elapsed_seconds'] for sample in samples] + if not 1 <= keep <= len(values) or any(not math.isfinite(value) or value <= 0 for value in values): + raise ValueError('invalid timing population') + return statistics.fmean(sorted(values)[:keep]) + + +def paired_interval(left, right): + """95% bootstrap interval for paired geometric ratios, using all measured rounds. + + This describes within-cell variability, not independent-machine reproducibility. + It deliberately differs from the existing chart's fastest-7/9 estimator. + """ + a = {sample['round']: sample['elapsed_seconds'] for sample in left} + b = {sample['round']: sample['elapsed_seconds'] for sample in right} + if len(a) != len(left) or len(b) != len(right) or a.keys() != b.keys() or not a: + raise ValueError('unpaired or duplicate rounds') + values = [math.log(a[key] / b[key]) for key in sorted(a)] + rng = random.Random(20261107) + estimates = sorted(math.exp(statistics.fmean(rng.choices(values, k=len(values)))) for _ in range(1000)) + return [estimates[24], estimates[974]] + + +def summarize_cell(row, contract): + participants = defaultdict(list) + for sample in row['samples']: + if sample['phase'] == 'measured': + participants[sample['label']].append(sample) + if set(participants) != set(row['commands']): + raise ValueError('missing participant measurements') + for samples in participants.values(): + if len(samples) != contract['repetitions'] or {s['round'] for s in samples} != set(range(1, contract['repetitions'] + 1)): + raise ValueError('missing or repeated sampling rounds') + if any(s['exit_codes'] != [0] or s['stderr_bytes'] or s['validated_records'] != row['expected_records'] for s in samples): + raise ValueError('unvalidated sample') + means = {label: mean_fastest(samples, contract['keep']) for label, samples in participants.items()} + references = set(means) - {'xff', 'anchor'} + if len(references) != 1: + raise ValueError('expected one traditional reference') + reference = references.pop() + lower, upper = paired_interval(participants['xff'], participants['anchor']) + resources = {} + for label, prefix in [('xff', 'xff'), ('anchor', 'anchor'), (reference, 'reference')]: + selected = sorted(participants[label], key=lambda sample: sample['elapsed_seconds'])[:contract['keep']] + resources[prefix + '_cpu_seconds'] = statistics.fmean( + sample['user_cpu_seconds'] + sample['system_cpu_seconds'] for sample in selected) + for kind in ('user', 'system'): + resources[prefix + '_' + kind + '_cpu_seconds'] = statistics.fmean( + sample[kind + '_cpu_seconds'] for sample in selected) + resources[prefix + '_rss_bytes'] = statistics.fmean(sample['peak_child_rss_bytes'] for sample in selected) + resources[prefix + '_first_stdout_seconds'] = statistics.fmean(sample['first_stdout_seconds'] for sample in selected) + return dict(row['case'], sha=row['revision']['sha'], pr=row['revision']['pr'], + binary_sha256=row['revision']['binary_sha256'], reference=reference, + xff_seconds=means['xff'], anchor_seconds=means['anchor'], reference_seconds=means[reference], + reference_over_xff=means[reference] / means['xff'], + historical_over_current=means['xff'] / means['anchor'], + current_time_reduction_percent=100 * (1 - means['anchor'] / means['xff']), + paired_ratio_ci_low=lower, paired_ratio_ci_high=upper, **resources) + + +def task_summaries(rows, contract): + """Equally weight the measured shape/worker combinations at each task and size.""" + populations = defaultdict(list) + for row in rows: + populations[(row['sha'], row['name'], row['files'])].append(row) + expected = defaultdict(set) + for case in contract['cases']: + expected[(case['name'], case['files'])].add((case['shape'], case['cpus'])) + summaries = [] + for (sha, name, files), group in populations.items(): + if {(row['shape'], row['cpus']) for row in group} != expected[(name, files)]: + continue + if len(group) != len(expected[(name, files)]): + raise ValueError('duplicate shape/worker measurements in task summary') + summaries.append({'sha': sha, 'pr': group[0]['pr'], 'name': name, 'files': files, + 'cells': len(group), 'binary_sha256': group[0]['binary_sha256'], + 'historical_over_current_geomean': statistics.geometric_mean( + row['historical_over_current'] for row in group), + 'xff_over_reference_geomean': statistics.geometric_mean( + 1 / row['reference_over_xff'] for row in group), + 'xff_over_reference_cpu_geomean': statistics.geometric_mean( + row['xff_cpu_seconds'] / row['reference_cpu_seconds'] for row in group)}) + return summaries + + +def current_reference_summaries(rows): + """Describe the repeated fixed-current/reference pairs across historical blocks. + + The spread is an observed distribution, not a confidence interval over machines. + Historical timings do not enter these ratios. + """ + populations = defaultdict(list) + for row in rows: + populations[(row['name'], row['shape'], row['files'], row['cpus'])].append(row) + summaries = [] + for (name, shape, files, cpus), group in populations.items(): + if len({row['sha'] for row in group}) != len(group): + raise ValueError('duplicate historical context in current/reference summary') + ratios = sorted(row['anchor_seconds'] / row['reference_seconds'] for row in group) + deciles = statistics.quantiles(ratios, n=10, method='inclusive') if len(ratios) > 1 else ratios * 9 + summaries.append({'name': name, 'shape': shape, 'files': files, 'cpus': cpus, + 'historical_contexts': len(group), 'reference': group[0]['reference'], + 'current_over_reference_geomean': statistics.geometric_mean(ratios), + 'current_over_reference_median': statistics.median(ratios), + 'current_over_reference_p10': deciles[0], + 'current_over_reference_p90': deciles[8], + 'current_over_reference_cpu_geomean': statistics.geometric_mean( + row['anchor_cpu_seconds'] / row['reference_cpu_seconds'] for row in group)}) + return summaries + + +def as_report(rows, contract, view): + """Adapt real cells without filling unmeasured sizes or mixing suite identities.""" + tasks = [] + for row in rows: + case = row['case'] + participants = {} + for label, command in row['commands'].items(): + if ((label == 'anchor' and view == 'traditional') or + (label not in ('xff', 'anchor') and view == 'anchor')): + continue + anchor = contract['anchor'] + anchor_id = str(anchor['pr']) if anchor['pr'] > 0 else anchor['sha'][:12] + name = 'xff-at-' + anchor_id if label == 'anchor' else label + participants[name] = {'pipeline': [command], 'cwd': row['cwd'], + 'samples': [sample for sample in row['samples'] + if sample['label'] == label and sample['phase'] == 'measured']} + tasks.append({'name': case['name'], 'dataset': case['shape'], 'shape': case['shape'], + 'files': case['files'], 'input_files': case['files'], 'cpus': case['cpus'], + 'expected_count': row['expected_records'], 'expected_sha256': row['expected_sha256'], + 'participants': participants, 'skips': {}}) + return {'contract': {'suite': contract['recipe'], 'platform': contract['platform'], + 'cpu_counts': sorted({case['cpus'] for case in contract['cases']}), + 'file_counts': sorted({case['files'] for case in contract['cases']}), + 'affinity_by_cpu_count': {str(n): contract['affinity'][:n] + for n in {case['cpus'] for case in contract['cases']}}, + 'repetitions': contract['repetitions'], 'retained': contract['keep'], + 'estimator': 'mean-fastest'}, 'tasks': tasks} + + +def export_viewer(output, contract, revisions, renderer, incomplete=False): + # Experiment manifests place the fixed baseline last for collection. The version + # slider must instead progress from that baseline to the candidate, regardless + # of collection time or hash spelling. Preserve merged-history chronology. + if all(revision['pr'] <= 0 for revision, _ in revisions): + revisions = sorted(revisions, key=lambda item: item[0]['sha'] != contract['anchor']['sha']) + assets = output / 'assets' + assets.mkdir(exist_ok=True) + shutil.copyfile(renderer, assets / 'three-landscape.js') + catalog = [] + anchor_label = revision_label(contract['anchor']) + for view, title in [('traditional', 'Traditional tools'), ('anchor', f'XFF comparison (fixed {anchor_label})')]: + reports = [(revision, rows, as_report(rows, contract, view)) for revision, rows in revisions] + order = landscape.common_task_order([matrix.relative_results(report) for _, _, report in reports]) + for revision, rows, report in reports: + directory = output / revision['sha'] + directory.mkdir(exist_ok=True) + data = landscape.figures(report, task_order=order) + (directory / (view + '.json')).write_text(json.dumps(data, allow_nan=False) + '\n') + document = landscape.render(report, '', task_order=order).replace( + '', '') + (directory / (view + '.html')).write_text(document) + experiment = revision['pr'] <= 0 + label = revision_label(revision) + catalog.append({'platform': contract['platform'] + ' / ' + contract['recipe'] + ' / ' + title, + 'platform_name': contract['platform'], 'dataset_type': contract['recipe'] + ' / ' + title, + 'commit': revision['sha'], 'date': revision['date'], + 'label': label + (' / ' + revision.get('subject', '') if experiment else ' / ' + revision['sha'][:10]), + 'source': 'experiment' if experiment else 'merged', + 'comparison_role': ('Baseline' if revision['sha'] == contract['anchor']['sha'] else 'Candidate') + if experiment else '', + 'source_label': 'Unmerged experiments' if experiment else 'Merged history', 'local': True, + 'measured': rows[-1]['after']['utc'], 'measurement_date': rows[-1]['after']['utc'], + 'report': revision['sha'] + '/' + view + '.html', + 'figures': revision['sha'] + '/' + view + '.json', + 'links': [] if experiment else [{'label': label, 'href': f'https://github.com/mboworks/xff/pull/{revision["pr"]}'}], + 'binary': {'state': 'Consistent', 'sha256': revision['binary_sha256'], + 'reason': 'Clean historical source, configured production ThinLTO build, frozen executable hash checked before and after collection.'}, + 'identity': contract['platform'] + ' extended qualification', + 'platform_details': contract['platform']}) + (output / 'catalog.json').write_text(json.dumps(catalog, indent=2) + '\n') + status = '

Collection in progress. Only complete revisions are shown.

' if incomplete else '' + intro = ('Extended benchmark history' + '' + '

Extended benchmark history

' + status + '

Independent extended suite; production full binaries on ' + + html.escape(contract['platform']) + '. ' + 'Each revision is interleaved with the fixed baseline binary and a traditional tool. ' + f'{len(revisions)} complete revisions are shown, including regressions and unchanged controls.

' + '

The XFF comparison dataset compares the selected binary with the fixed baseline. ' + 'The baseline revision is an identical-binary control and should be near zero. ' + 'Unmerged comparisons show the baseline first and candidates afterward; the Version card identifies each role. ' + 'Collection timestamps do not determine this order.

' + '

Download: Measurements · ' + 'History by task · ' + 'Current tool comparisons (CSV).

') + panel = landscape.history_panel(catalog, include_overview=False).replace( + '', '') + (output / 'index.html').write_text(intro + panel + '') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--campaign', type=Path, required=True) + parser.add_argument('--output', type=Path, required=True) + parser.add_argument('--renderer-js', type=Path) + parser.add_argument('--allow-partial', action='store_true') + args = parser.parse_args() + root = args.campaign + if (root / 'invalid.json').exists(): + raise ValueError('campaign identity verification failed') + progress = json.loads((root / 'progress.json').read_text()) + if not args.allow_partial and progress['state'] != 'complete': + raise ValueError('measurement campaign is not complete') + contract = json.loads((root / 'contract.json').read_text()) + output = args.output + output.mkdir(parents=True, exist_ok=True) + rows, revisions = [], [] + for revision in contract['revisions']: + cells = [] + for case in contract['cases']: + path = root / 'cells' / revision['sha'] / suite.Case(**case).key / 'complete.json' + if not path.exists() and args.allow_partial: + continue + row = json.loads(path.read_text()) + if row['case'] != case or row['revision'] != revision or row['anchor'] != contract['anchor']: + raise ValueError('cell provenance differs from campaign contract') + rows.append(summarize_cell(row, contract)) + cells.append(row) + if len(cells) == len(contract['cases']): + revisions.append((revision, cells)) + if not rows: + raise ValueError('no completed measurement cells') + with (output / 'cells.csv').open('w') as file: + writer = csv.DictWriter(file, fieldnames=list(rows[0])) + writer.writeheader() + writer.writerows(rows) + groups = task_summaries(rows, contract) + if groups: + with (output / 'history-by-task.csv').open('w') as file: + writer = csv.DictWriter(file, fieldnames=list(groups[0])) + writer.writeheader() + writer.writerows(groups) + current = current_reference_summaries(rows) + with (output / 'current-versus-reference.csv').open('w') as file: + writer = csv.DictWriter(file, fieldnames=list(current[0])) + writer.writeheader() + writer.writerows(current) + controls = [row for row in rows if row['binary_sha256'] == contract['anchor']['binary_sha256']] + noise = sorted(abs(math.log(row['historical_over_current'])) for row in controls) + summary = {'recipe': contract['recipe'], 'state': progress['state'], 'cells': len(rows), + 'complete_revisions': len(revisions), 'expected_revisions': len(contract['revisions']), + 'identical_binary_control_cells': len(controls), + 'control_p95_factor': math.exp(noise[min(len(noise) - 1, int(len(noise) * .95))]) if noise else None, + 'interval': '95% paired-round bootstrap geometric ratio; within-cell variability only', + 'task_summary': 'Geometric means equally weight all declared shape/worker combinations; incomplete groups are omitted.', + 'current_reference_summary': 'Fixed-current/reference ratios across historical blocks; p10/p90 describe observed spread, not independent-machine confidence.', + 'contract_sha256': hashlib.sha256((root / 'contract.json').read_bytes()).hexdigest(), + 'endpoints': endpoint_summaries(rows, contract)} + (output / 'summary.json').write_text(json.dumps(summary, indent=2) + '\n') + if args.renderer_js and revisions: + export_viewer(output, contract, revisions, args.renderer_js, incomplete=progress['state'] != 'complete') + print(json.dumps({key: value for key, value in summary.items() if key != 'endpoints'}, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/tools/benchmark_extended_report_test.py b/tools/benchmark_extended_report_test.py new file mode 100644 index 00000000000..4d0650f3a02 --- /dev/null +++ b/tools/benchmark_extended_report_test.py @@ -0,0 +1,169 @@ +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Check historical ratios, paired uncertainty, and real-only renderer populations.""" + +import copy +import json +from pathlib import Path +import tempfile +import unittest + +import benchmark_extended_report as report + + +class BenchmarkExtendedReportTest(unittest.TestCase): + def row(self): + return {'case': {'name': 'archive-tar', 'shape': 'broad', 'files': 100, 'cpus': 1}, + 'revision': {'sha': 'old', 'pr': 1, 'binary_sha256': 'hash'}, 'expected_records': 50, + 'expected_sha256': 'oracle', 'cwd': '/fixture', + 'commands': {'xff': ['/old/xff'], 'anchor': ['/new/xff'], 'tar': ['/bin/tar']}, + 'samples': [dict(label=label, round=repetition, phase='measured' if repetition else 'warmup', + elapsed_seconds=seconds if repetition else 500, + user_cpu_seconds=seconds / 2, system_cpu_seconds=seconds / 4, + peak_child_rss_bytes=seconds * 1000, first_stdout_seconds=seconds / 10, + exit_codes=[0], stderr_bytes=0, validated_records=50) + for repetition in range(4) for label, seconds in [('xff', 4), ('anchor', 2), ('tar', 8)]]} + + def contract(self): + return {'repetitions': 3, 'keep': 2, 'anchor': {'pr': 2}, 'recipe': 'extended-production-v1', + 'platform': 'Linux', 'cases': [self.row()['case']], 'affinity': [0, 1, 2]} + + def test_known_ratios_and_warmup_exclusion(self): + result = report.summarize_cell(self.row(), self.contract()) + self.assertEqual(result['xff_seconds'], 4) + self.assertEqual(result['historical_over_current'], 2) + self.assertEqual(result['reference_over_xff'], 2) + self.assertEqual(result['current_time_reduction_percent'], 50) + self.assertEqual(result['paired_ratio_ci_low'], 2) + self.assertEqual(result['paired_ratio_ci_high'], 2) + self.assertEqual(result['xff_cpu_seconds'], 3) + self.assertEqual(result['anchor_cpu_seconds'], 1.5) + self.assertEqual(result['xff_user_cpu_seconds'], 2) + self.assertEqual(result['xff_system_cpu_seconds'], 1) + self.assertEqual(result['xff_rss_bytes'], 4000) + self.assertEqual(result['xff_first_stdout_seconds'], .4) + + def test_export_links_tables_without_an_unrelated_merged_baseline_overview(self): + row = self.row() + row['revision']['date'] = '2026-11-07' + row['after'] = {'utc': '2026-11-07T12:00:00Z'} + rows = [dict(row, case=dict(row['case'], shape=shape, files=files, cpus=cpus)) + for shape in ('broad', 'deep') for files in (100, 1000) for cpus in (1, 3)] + contract = dict(self.contract(), cases=[item['case'] for item in rows]) + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + renderer = root / 'renderer.js' + renderer.write_text('/* renderer fixture */') + report.export_viewer(root, contract, [(row['revision'], rows)], renderer) + document = (root / 'index.html').read_text() + self.assertNotIn('data-overview', document) + for name in ('cells.csv', 'history-by-task.csv', 'current-versus-reference.csv'): + self.assertIn(f'href="{name}"', document) + self.assertIn('1 complete revisions', document) + + def test_missing_duplicate_and_incorrect_samples_are_rejected(self): + row = self.row() + variants = [copy.deepcopy(row) for _ in range(3)] + variants[0]['samples'].pop() + variants[1]['samples'][-1]['round'] = 2 + variants[2]['samples'][-1]['validated_records'] = 49 + for variant in variants: + with self.assertRaises(ValueError): + report.summarize_cell(variant, self.contract()) + + def test_experiments_keep_distinct_endpoints_and_do_not_claim_merged_prs(self): + candidate = dict(self.row()['revision'], sha='candidate', pr=0, date='2026-11-07') + baseline = dict(candidate, sha='baseline') + rows = [dict(self.row(), revision=candidate, after={'utc': '2026-11-07T12:00:00Z'}, + case=dict(self.row()['case'], files=files, cpus=cpus)) + for files in (100, 1000) for cpus in (1, 3)] + contract = dict(self.contract(), anchor=baseline, revisions=[candidate, baseline], + cases=[row['case'] for row in rows], platform='Darwin') + summaries = report.endpoint_summaries([dict(sha='candidate'), dict(sha='baseline')], contract) + self.assertEqual(set(summaries), {'candidate', 'baseline'}) + self.assertEqual(summaries['candidate'], [dict(sha='candidate')]) + adapted = report.as_report(rows, contract, 'anchor') + self.assertEqual(set(adapted['tasks'][0]['participants']), {'xff', 'xff-at-baseline'}) + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + renderer = root / 'renderer.js' + renderer.write_text('/* renderer fixture */') + baseline_rows = [dict(row, revision=baseline, after={'utc': '2026-11-07T13:00:00Z'}) for row in rows] + report.export_viewer(root, contract, [(candidate, rows), (baseline, baseline_rows)], renderer) + catalog = json.loads((root / 'catalog.json').read_text()) + for platform in {item['platform'] for item in catalog}: + records = [item for item in catalog if item['platform'] == platform] + self.assertEqual([item['commit'] for item in records], ['baseline', 'candidate']) + self.assertEqual([item['comparison_role'] for item in records], ['Baseline', 'Candidate']) + for item in catalog: + self.assertEqual(item['source'], 'experiment') + self.assertEqual(item['links'], []) + self.assertIn('Experiment ' + item['commit'], item['label']) + self.assertIn('Darwin', item['platform']) + document = (root / 'index.html').read_text() + self.assertNotIn('PR #0', document) + self.assertNotIn('Linux tmpfs', document) + + def test_fastest_estimator_and_control_interval(self): + self.assertEqual(report.mean_fastest([{'elapsed_seconds': value} for value in (2, 5, 1)], 2), 1.5) + samples = [{'round': i, 'elapsed_seconds': value} for i, value in enumerate([1, 2, 3])] + self.assertEqual(report.paired_interval(samples, samples), [1, 1]) + with self.assertRaises(ValueError): + report.paired_interval(samples, [*samples, samples[-1]]) + + def test_renderer_adapter_does_not_invent_cells_or_mix_references(self): + for view, expected in [('traditional', {'xff', 'tar'}), ('anchor', {'xff', 'xff-at-2'})]: + adapted = report.as_report([self.row()], self.contract(), view) + self.assertEqual(len(adapted['tasks']), 1) + self.assertEqual(adapted['contract']['file_counts'], [100]) + self.assertEqual(adapted['contract']['suite'], 'extended-production-v1') + task = adapted['tasks'][0] + self.assertEqual(task['files'], 100) + self.assertEqual(task['dataset'], 'broad') + self.assertEqual(set(task['participants']), expected) + for participant in task['participants'].values(): + self.assertEqual(len(participant['samples']), 3) + + def test_task_summary_requires_complete_unique_shape_worker_population(self): + contract = self.contract() + contract['cases'].append(dict(contract['cases'][0], cpus=3)) + first = report.summarize_cell(self.row(), contract) + second = dict(first, cpus=3, historical_over_current=8, reference_over_xff=8) + self.assertEqual(report.task_summaries([first], contract), []) + group = report.task_summaries([first, second], contract)[0] + self.assertEqual(group['cells'], 2) + self.assertEqual(group['historical_over_current_geomean'], 4) + self.assertEqual(group['xff_over_reference_geomean'], .25) + self.assertEqual(group['xff_over_reference_cpu_geomean'], .5) + with self.assertRaises(ValueError): + report.task_summaries([first, first, second], contract) + + def test_resource_summary_uses_samples_selected_by_wall_time(self): + row = self.row() + # A slow timing with tiny CPU must not enter the fastest-two resource mean. + slow = next(sample for sample in row['samples'] + if sample['label'] == 'xff' and sample['round'] == 3) + slow.update(elapsed_seconds=100, user_cpu_seconds=.01, system_cpu_seconds=.01) + result = report.summarize_cell(row, self.contract()) + self.assertEqual(result['xff_seconds'], 4) + self.assertEqual(result['xff_cpu_seconds'], 3) + + def test_current_reference_summary_uses_fixed_anchor_and_preserves_cells(self): + first = report.summarize_cell(self.row(), self.contract()) + second = dict(first, sha='other', xff_seconds=100, historical_over_current=50) + separate = dict(first, files=1000) + summaries = report.current_reference_summaries([first, second, separate]) + self.assertEqual(len(summaries), 2) + self.assertEqual(summaries[0]['historical_contexts'], 2) + self.assertEqual(summaries[0]['current_over_reference_geomean'], .25) + self.assertEqual(summaries[0]['current_over_reference_p10'], .25) + self.assertEqual(summaries[0]['current_over_reference_p90'], .25) + self.assertEqual(summaries[0]['current_over_reference_cpu_geomean'], .25) + self.assertEqual(summaries[1]['historical_contexts'], 1) + self.assertEqual(summaries[1]['current_over_reference_p10'], .25) + with self.assertRaises(ValueError): + report.current_reference_summaries([first, first]) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/benchmark_extended_test.py b/tools/benchmark_extended_test.py new file mode 100644 index 00000000000..a0a0de1bcdb --- /dev/null +++ b/tools/benchmark_extended_test.py @@ -0,0 +1,106 @@ +# SPDX-FileCopyrightText: Copyright (c) M. Boerger, the MBO Works authors +# SPDX-License-Identifier: Apache-2.0 +"""Check fixture semantics and reject incorrect benchmark outputs.""" + +from pathlib import Path +import re +import tarfile +import tempfile +import unittest + +import benchmark_extended as suite + + +class BenchmarkExtendedTest(unittest.TestCase): + def test_case_grid_has_unique_cells_and_bounded_archive_sizes(self): + cases = suite.cases() + self.assertEqual(len(cases), 60) + self.assertEqual(len({case.key for case in cases}), len(cases)) + self.assertEqual({c.files for c in cases if c.name == 'archive-tar'}, {100, 1000, 10000}) + self.assertEqual({c.files for c in cases if c.name != 'archive-tar'}, {100, 10000, 100000}) + for name in suite.TASKS: + self.assertEqual({c.cpus for c in cases if c.name == name}, {1, 3}) + for values in [('unknown', 'broad', 1, 1), ('files-exact', 'wide', 1, 1), + ('files-exact', 'deep', 0, 1), ('files-exact', 'deep', 1, 0)]: + with self.assertRaises(ValueError): + suite.Case(*values) + + def test_content_fixture_matches_the_regex_and_preserves_nonmatches(self): + rows = list(suite.entries('broad', 100)) + self.assertEqual(len(rows), 100) + self.assertEqual({len(data) for _, data, _ in rows}, {256, 8192}) + actual = [name for name, data, _ in rows if re.search(suite.PATTERN.encode(), data)] + self.assertEqual(actual, [f'item_{i:06}.txt' if i % 2 == 0 else f'item_{i:06}.log' + for i in range(0, 100, 3)]) + + def test_oracles_have_explicit_paths_metadata_and_selections(self): + parent = Path('/fixture') + expectations = { + 'files-exact': [b'./item_000000.txt', b'./item_000001.log', b'./item_000002.txt'], + 'name-native': [b'/fixture/native/broad/3/item_000000.txt', b'/fixture/native/broad/3/item_000002.txt'], + 'metadata-time': [b'/fixture/native/broad/3/item_000000.txt\t8192\t2020-01-02', + b'/fixture/native/broad/3/item_000002.txt\t256\t2020-01-02'], + 'content-regex': [b'/fixture/native/broad/3/item_000000.txt'], + 'archive-tar': [b'fixture.tar/d0000/item_000000.txt', b'fixture.tar/d0000/item_000002.txt'], + } + for task, expected in expectations.items(): + with self.subTest(task=task): + self.assertEqual(suite.expected(suite.Case(task, 'broad', 3, 1), parent), expected) + + def test_materialized_native_and_archive_fixtures_match_recipe(self): + cases = [suite.Case(task, shape, 6, 1) for task in ('files-exact', 'archive-tar') for shape in ('broad', 'deep')] + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) / 'fixture' + suite.prepare(root, cases) + self.assertEqual(len(suite.verify(root, cases)['fixtures']), 4) + for shape in ('broad', 'deep'): + with tarfile.open(root / 'archive' / shape / '6/fixture.tar') as archive: + members = archive.getmembers() + self.assertEqual(len(members), 6) + for member, (name, data, _) in zip(members, suite.entries(shape, 6, True), strict=True): + self.assertEqual(member.name, name) + self.assertTrue(member.isfile()) + self.assertEqual(member.mtime, suite.MTIME) + self.assertEqual(archive.extractfile(member).read(), data) + with self.assertRaises(FileExistsError): + suite.prepare(root, cases) + + def test_fixture_changes_are_rejected(self): + case = suite.Case('files-exact', 'broad', 3, 1) + mutations = [lambda root: (root / 'native/broad/3/item_000000.txt').write_bytes(b'wrong'), + lambda root: (root / 'native/broad/3/item_000000.txt').chmod(0o600), + lambda root: (root / 'native/broad/3/extra').write_bytes(b'extra')] + for mutation in mutations: + with tempfile.TemporaryDirectory() as temporary: + root = Path(temporary) / 'fixture' + suite.prepare(root, [case]) + mutation(root) + with self.assertRaisesRegex(ValueError, 'changed'): + suite.verify(root, [case]) + + def test_validation_compares_multisets_and_checks_status_and_bytes(self): + sample = {'exit_codes': [0], 'stderr_bytes': 0, 'stderr': '', 'output': b'b\0a\0', 'stdout_bytes': 4} + self.assertEqual(len(suite.validate(sample, [b'a', b'b'], b'\0')), 64) + for changes in ({'output': b'a\0a\0'}, {'output': b'a\0', 'stdout_bytes': 2}, + {'output': b'b\0a'}, {'exit_codes': [1]}, {'stderr_bytes': 4, 'stderr': 'oops'}, + {'stdout_bytes': 5}): + with self.subTest(changes=changes), self.assertRaises(ValueError): + suite.validate(dict(sample, **changes), [b'a', b'b'], b'\0') + + def test_commands_keep_native_case_and_equivalent_archive_paths(self): + tools = {'find': '/bin/find', 'rg': '/bin/rg', 'tar': '/bin/tar'} + commands, _, separator = suite.commands(suite.Case('name-native', 'deep', 100, 3), + Path('/fixture'), '/bin/xff', tools) + self.assertNotIn('--exact', commands['xff']) + self.assertFalse(any(arg.startswith('--case=') for arg in commands['xff'])) + self.assertIn('--jobs=3', commands['xff']) + commands, _, separator = suite.commands(suite.Case('archive-tar', 'deep', 100, 1), + Path('/fixture'), '/bin/xff', tools) + self.assertEqual(separator, b'\n') + self.assertIn('--archive-separator=/', commands['xff']) + self.assertIn('--transform=s,^,fixture.tar/,', commands['tar']) + self.assertNotIn('-printf', commands['xff']) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/benchmark_landscape.py b/tools/benchmark_landscape.py index 5a2c9c82c76..514e80488ca 100644 --- a/tools/benchmark_landscape.py +++ b/tools/benchmark_landscape.py @@ -405,9 +405,12 @@ def view_controls(attribute): ' ') -def history_panel(catalog): +def history_panel(catalog, *, include_overview=True): """A bounded catalog; only the selected report's six views are downloaded.""" data = json.dumps(catalog, allow_nan=False).replace('<', '\\u003c') + overview = ('

Performance overview

' + '

Select a measurement to compare it with its recorded merged baseline.

' + if include_overview else '') return ('
' '
' '
' @@ -449,6 +452,7 @@ def history_panel(catalog): 'Version
' '' '' + '' '' '' '' @@ -466,8 +470,7 @@ def history_panel(catalog): '' '' - '

Performance overview

' - '

Select a measurement to compare it with its recorded merged baseline.

' + + overview + '') diff --git a/tools/benchmark_landscape_test.py b/tools/benchmark_landscape_test.py index 41aaa25fa9f..d824d0e70ac 100644 --- a/tools/benchmark_landscape_test.py +++ b/tools/benchmark_landscape_test.py @@ -570,6 +570,14 @@ def test_history_has_no_duplicate_chart_heading(self): self.assertNotIn('3D comparison chart (show/hide)', text) self.assertNotIn('Comparison landscape history', text) + def test_history_overview_can_be_omitted_for_separate_comparison_contracts(self): + self.assertIn('data-overview', landscape.history_panel([])) + text = landscape.history_panel([], include_overview=False) + self.assertNotIn('data-overview', text) + self.assertNotIn('Performance overview', text) + self.assertIn('data-chart', text) + self.assertIn('window.XffBenchmarkHistory', text) + def test_history_fold_control_is_in_page_title_and_publication_is_idempotent(self): with tempfile.TemporaryDirectory() as directory: root = Path(directory) diff --git a/tools/benchmark_web/history.js b/tools/benchmark_web/history.js index 21074d64295..e9d12dfaa45 100644 --- a/tools/benchmark_web/history.js +++ b/tools/benchmark_web/history.js @@ -109,6 +109,12 @@ window.XffBenchmarkHistory = function historyExplorer(root, catalog) { reportLink.title = `Open the full benchmark report: ${reportText}`; root.querySelector("[data-version-count]").textContent = `${index + 1} of ${records.length}`; + const comparisonRow = root.querySelector("[data-comparison-row]"); + if (comparisonRow) { + comparisonRow.hidden = !record.comparison_role; + comparisonRow.querySelector("[data-comparison-role]").textContent = + record.comparison_role || ""; + } updateVersionControls(); const parts = record.platform.split(" / "); const local = parts[0] === "Local"; @@ -267,8 +273,14 @@ window.XffBenchmarkHistory = function historyExplorer(root, catalog) { disclosure.addEventListener("toggle", (event) => { if (event.target.open) requestAnimationFrame(() => chart?.resize()); }); - if (catalog.length) selectSource(); - else { + if (catalog.length) { + if ( + source && + !catalog.some((row) => (row.source || "merged") === source.value) + ) + source.value = catalog[0].source || "merged"; + selectSource(); + } else { status.hidden = false; status.textContent = "No retained reports have comparison landscape data."; } diff --git a/tools/benchmark_web/landscape.test.mjs b/tools/benchmark_web/landscape.test.mjs index 2a4641a71a7..d658ebe32cc 100644 --- a/tools/benchmark_web/landscape.test.mjs +++ b/tools/benchmark_web/landscape.test.mjs @@ -426,7 +426,7 @@ test("history platform/version controls preserve selection and recover from load import sys, json, hashlib, io from pathlib import Path sys.path.insert(0, sys.argv[1]) -from benchmark_landscape import publish +from benchmark_landscape import publish, history_panel from benchmark_landscape_test import report, preview_report from benchmark_provenance import verify_retention root = Path(sys.argv[3]) @@ -462,6 +462,9 @@ folder.mkdir(parents=True) source=dict(id=4, run_attempt=1, head_branch='feature', event='pull_request', pull_requests=[{'number': 952}], created_at='2026-10-03T00:00:00Z')))) publish(root, Path(sys.argv[2]).read_text(), [folder / 'report.json']) +experiments = [dict(row, source='experiment', source_label='Unmerged experiments', comparison_role='Candidate') + for row in json.loads((root / 'catalog.json').read_text()) if row.get('source') == 'pr-952'] +(root / 'experiments.html').write_text(history_panel(experiments, include_overview=False)) `, tools, bundle, @@ -856,6 +859,23 @@ publish(root, Path(sys.argv[2]).read_text(), [folder / 'report.json']) await page.locator("[data-overview]").textContent(), /regression status is unknown/, ); + await page.goto( + `http://127.0.0.1:${server.address().port}/experiments.html`, + ); + await waitCommit("d"); + assert.equal( + await page.locator('[data-control="source"]').inputValue(), + "experiment", + ); + assert.equal(await page.locator("[data-comparison-row]").isVisible(), true); + assert.equal( + await page.locator("[data-comparison-role]").textContent(), + "Candidate", + ); + assert.equal( + await page.locator('[data-control="platform"]').inputValue(), + "linux", + ); assert.deepEqual(errors, []); } finally { await browser.close(); diff --git a/xff/content/snapshot.cc b/xff/content/snapshot.cc index a244d9ec9f6..8b544166765 100644 --- a/xff/content/snapshot.cc +++ b/xff/content/snapshot.cc @@ -20,13 +20,14 @@ void Derivation::Include(Derivation other) { } absl::StatusOr Snapshot::Read(const vfs::FileSystem& fs, std::string_view path) const { - if (!bytes_) { - bytes_ = fs.ReadContent(path); + auto& bytes = Storage().bytes; + if (!bytes) { + bytes = fs.ReadContent(path); } - if (!bytes_->ok()) { - return bytes_->status(); + if (!bytes->ok()) { + return bytes->status(); } - return std::string_view(**bytes_); + return std::string_view(**bytes); } std::optional Snapshot::Digest( @@ -48,7 +49,7 @@ const std::optional& Snapshot::DigestValue( const vfs::FileSystem& fs, std::string_view path, const hash::AlgoEncoding& spec) const { - auto [entry, inserted] = digests_.try_emplace(std::pair{std::string(spec.algo), spec.encoding}); + auto [entry, inserted] = Storage().digests.try_emplace(std::pair{std::string(spec.algo), spec.encoding}); if (inserted) { const auto bytes = Read(fs, path); if (bytes.ok()) { @@ -59,34 +60,35 @@ const std::optional& Snapshot::DigestValue( } std::optional Snapshot::Lines(const vfs::FileSystem& fs, std::string_view path) const { - if (!lines_) { + auto& lines = Storage().lines; + if (!lines) { const auto bytes = Read(fs, path); - lines_.emplace(bytes.ok() ? ContentLineCount(*bytes) : std::nullopt); + lines.emplace(bytes.ok() ? ContentLineCount(*bytes) : std::nullopt); } - return *lines_; + return *lines; } Snapshot Snapshot::TakeDerived(const Derivation& request, const vfs::FileSystem& fs, std::string_view path) && { Snapshot derived; - if (!Loaded()) { + if (!Loaded() || request.Empty()) { return derived; } + auto& source = Storage(); + auto& target = derived.Storage(); if (request.lines) { static_cast(Lines(fs, path)); - derived.lines_ = std::exchange(lines_, std::nullopt); + target.lines = std::exchange(source.lines, std::nullopt); } for (const auto& digest : request.digests) { static_cast(DigestValue(fs, path, {.algo = digest.algorithm, .encoding = digest.encoding})); - auto node = digests_.extract(std::pair{digest.algorithm, digest.encoding}); - derived.digests_.insert(std::move(node)); + auto node = source.digests.extract(std::pair{digest.algorithm, digest.encoding}); + target.digests.insert(std::move(node)); } return derived; } void Snapshot::Invalidate() { - bytes_.reset(); - digests_.clear(); - lines_.reset(); + state_.reset(); } } // namespace xff::content diff --git a/xff/content/snapshot.h b/xff/content/snapshot.h index b9097867b2c..3efd6c844df 100644 --- a/xff/content/snapshot.h +++ b/xff/content/snapshot.h @@ -39,6 +39,10 @@ struct Derivation { // Invalidate at effect boundaries and before using a different entry. Views expire on invalidation. class Snapshot final { public: + // Keep unused inline storage unconstructed, including when an enclosing context is + // value-initialized. A defaulted constructor could zero-initialize the whole snapshot. + Snapshot() noexcept : state_(std::nullopt) {} + absl::StatusOr Read(const vfs::FileSystem& fs, std::string_view path) const; std::optional Digest(const vfs::FileSystem& fs, std::string_view path, const hash::AlgoEncoding& spec) const; @@ -56,7 +60,7 @@ class Snapshot final { // a VFS read and the returned snapshot owns no raw content, including on a cached read error. Snapshot TakeDerived(const Derivation& request, const vfs::FileSystem& fs, std::string_view path) &&; - bool Loaded() const { return bytes_.has_value(); } + bool Loaded() const { return state_ && state_->bytes.has_value(); } private: const std::optional& DigestValue( @@ -64,9 +68,16 @@ class Snapshot final { std::string_view path, const hash::AlgoEncoding& spec) const; - mutable std::optional> bytes_; - mutable std::map, std::optional> digests_; - mutable std::optional> lines_; + struct State { + std::optional> bytes; + std::map, std::optional> digests; + std::optional> lines; + }; + + State& Storage() const { return state_ ? *state_ : state_.emplace(); } + + // Reserve cache storage with the evaluator, but construct it only for a content consumer. + mutable std::optional state_; }; } // namespace xff::content diff --git a/xff/content/snapshot_test.cc b/xff/content/snapshot_test.cc index 93b25e30afa..1f51b1afc43 100644 --- a/xff/content/snapshot_test.cc +++ b/xff/content/snapshot_test.cc @@ -60,6 +60,49 @@ struct SnapshotTest : ::testing::Test { Snapshot snapshot; }; +TEST_F(SnapshotTest, EmptySnapshotsRemainLazyAcrossCopyMoveAndInvalidation) { + Snapshot copied(snapshot); + Snapshot moved(std::move(copied)); + snapshot.Invalidate(); + snapshot.Invalidate(); + moved.Invalidate(); + const auto derived = std::move(moved).TakeDerived({.lines = true}, fs, "file"); + EXPECT_THAT(snapshot.Loaded(), IsFalse()); + EXPECT_THAT(derived.Loaded(), IsFalse()); + EXPECT_THAT(fs.reads, Eq(0)); + EXPECT_THAT(derived.Lines(fs, "file"), Optional(2)); + EXPECT_THAT(fs.reads, Eq(1)); +} + +TEST_F(SnapshotTest, AssignmentReplacesCachedContentAndDerivedValues) { + EXPECT_THAT(snapshot.Lines(fs, "file"), Optional(2)); + const auto digest = snapshot.Digest(fs, "file", {.algo = "sha256"}); + Snapshot copied(snapshot); + snapshot = Snapshot{}; + EXPECT_THAT(snapshot.Loaded(), IsFalse()); + fs.bytes = "replacement"; + EXPECT_THAT(snapshot.Lines(fs, "file"), Optional(1)); + snapshot = copied; + EXPECT_THAT(snapshot.Lines(fs, "file"), Optional(2)); + EXPECT_THAT(snapshot.Digest(fs, "file", {.algo = "sha256"}), Eq(digest)); + copied.Invalidate(); + EXPECT_THAT(snapshot.Lines(fs, "file"), Optional(2)); + snapshot = std::move(copied); + EXPECT_THAT(snapshot.Loaded(), IsFalse()); + EXPECT_THAT(snapshot.Lines(fs, "file"), Optional(1)); + EXPECT_THAT(fs.reads, Eq(3)); +} + +TEST_F(SnapshotTest, EmptyDerivationTransfersNoCachesOrBytes) { + EXPECT_THAT(snapshot.Lines(fs, "file"), Optional(2)); + const auto derived = std::move(snapshot).TakeDerived({}, fs, "file"); + EXPECT_THAT(derived.Loaded(), IsFalse()); + EXPECT_THAT(fs.reads, Eq(1)); + fs.bytes = "replacement"; + EXPECT_THAT(derived.Lines(fs, "file"), Optional(1)); + EXPECT_THAT(fs.reads, Eq(2)); +} + TEST_F(SnapshotTest, DerivedTransferRetainsRequestedValuesWithoutRetainingBytes) { EXPECT_THAT(snapshot.Read(fs, "file"), IsOkAndHolds(EqualsText(fs.bytes))); const auto digest = hash::HashData("md5", fs.bytes).value_or("unsupported"); diff --git a/xff/engine/BUILD.bazel b/xff/engine/BUILD.bazel index d708ea7451b..72ebaef0265 100644 --- a/xff/engine/BUILD.bazel +++ b/xff/engine/BUILD.bazel @@ -276,6 +276,7 @@ cc_library( "//xff/presentation/fields:fields_cc", "//xff/presentation/format:format_cc", "//xff/presentation/patch:patch_cc", + "//xff/presentation/render:record_buffer_cc", "//xff/presentation/render:render_cc", "//xff/registry:registry_cc", "//xff/values:values_cc", diff --git a/xff/engine/evaluate.cc b/xff/engine/evaluate.cc index 11fbc9bc9e2..89bf71eca05 100644 --- a/xff/engine/evaluate.cc +++ b/xff/engine/evaluate.cc @@ -77,6 +77,7 @@ #include "xff/parser/ast.h" #include "xff/presentation/fields/fields.h" #include "xff/presentation/patch/patch.h" +#include "xff/presentation/render/record_buffer.h" #include "xff/presentation/render/render.h" #include "xff/registry/descriptor.h" #include "xff/values/values.h" @@ -975,20 +976,39 @@ bool EvalFalse(const parser::Expr&, EvalContext&) { // folds the case-sensitive variant when FS-native matching is in effect (the // entry is on a case-folding volume, xff style, no --exact), so -name matches // the way the filesystem itself resolves names. +template +bool MatchNativeGlob(const parser::Expr& expr, const EvalContext& ctx, const Matches& matches) { + if (expr.descriptor->fold_case || ctx.fold_name_case || expr.case_fold) { + return matches(FNM_CASEFOLD); + } + const bool exact = matches(0); + if (!ctx.resolve_name_case) { + return exact; + } + const bool folded = matches(FNM_CASEFOLD); + // Folding can also remove a match (for example [!A] against a). Compare both truth values + // rather than assuming that case-insensitive matching is always a superset. + if (exact == folded) { + return exact; + } + return (*ctx.resolve_name_case)() ? folded : exact; +} + // NOLINTNEXTLINE(misc-const-correctness): EvalFn requires a mutable context. bool EvalName(const parser::Expr& expr, EvalContext& ctx) { - const int flags = (expr.descriptor->fold_case || ctx.fold_name_case || expr.case_fold) ? FNM_CASEFOLD : 0; - return !expr.args.empty() && Fnmatch(expr.args.front(), ctx.visit.name, flags); + return !expr.args.empty() + && MatchNativeGlob(expr, ctx, [&](int flags) { return Fnmatch(expr.args.front(), ctx.visit.name, flags); }); } // The selected fuzzy model (see //xff/fuzzy), over whichever text the primary matches. Case follows // the same three-way rule -name uses: the always-folding variant, the FS-native default, or an // explicit --case. bool EvalFuzzyOn(const parser::Expr& expr, EvalContext& ctx, std::string_view subject) { - const bool fold = expr.descriptor->fold_case || ctx.fold_name_case || expr.case_fold; if (expr.args.empty()) { return false; } + const bool fold = expr.descriptor->fold_case || ctx.fold_name_case || expr.case_fold + || (ctx.resolve_name_case && (*ctx.resolve_name_case)()); if (!ctx.fuzzy_score.has_value() && !expr.fuzzy_threshold.has_value()) { if (expr.fuzzy_model == parser::FuzzyModel::kSequence) { return fuzzy::Matches(expr.args.front(), subject, fold); @@ -1070,8 +1090,8 @@ bool EvalFuzzyPath(const parser::Expr& expr, EvalContext& ctx) { // NOLINTNEXTLINE(misc-const-correctness): EvalFn requires a mutable context. bool EvalPath(const parser::Expr& expr, EvalContext& ctx) { - const int flags = (expr.descriptor->fold_case || ctx.fold_name_case || expr.case_fold) ? FNM_CASEFOLD : 0; - return !expr.args.empty() && Fnmatch(expr.args.front(), ctx.visit.path, flags); + return !expr.args.empty() + && MatchNativeGlob(expr, ctx, [&](int flags) { return Fnmatch(expr.args.front(), ctx.visit.path, flags); }); } // {target} render support: a symlink's target text (find %l) for the field @@ -2611,13 +2631,21 @@ std::string LsRecord(const Visit& visit, absl::Time now, absl::TimeZone tz, std: // NOLINTNEXTLINE(misc-const-correctness): EvalFn requires a mutable context. bool EvalPrint(const parser::Expr&, EvalContext& ctx) { - ctx.emit(PrintRecord(ctx.visit)); + if (ctx.path_records) { + ctx.path_records->EmitRecord(ctx.visit.path, '\n', ctx.emit); + } else { + ctx.emit(PrintRecord(ctx.visit)); + } return true; } // NOLINTNEXTLINE(misc-const-correctness): EvalFn requires a mutable context. bool EvalPrint0(const parser::Expr&, EvalContext& ctx) { - ctx.emit(Print0Record(ctx.visit)); + if (ctx.path_records) { + ctx.path_records->EmitRecord(ctx.visit.path, '\0', ctx.emit); + } else { + ctx.emit(Print0Record(ctx.visit)); + } return true; } @@ -3306,9 +3334,9 @@ bool EvalPreparedName( ExecutionSlots, // NOLINTNEXTLINE(misc-const-correctness): PreparedEvalFn requires a mutable context. EvalContext& context) { - const int flags = - (expression.descriptor->fold_case || context.fold_name_case || expression.case_fold) ? FNM_CASEFOLD : 0; - return MatchesPreparedGlob(expression, operand, context.visit.name, flags); + return MatchNativeGlob(expression, context, [&](int flags) { + return MatchesPreparedGlob(expression, operand, context.visit.name, flags); + }); } bool EvalPreparedPath( @@ -3317,9 +3345,9 @@ bool EvalPreparedPath( ExecutionSlots, // NOLINTNEXTLINE(misc-const-correctness): PreparedEvalFn requires a mutable context. EvalContext& context) { - const int flags = - (expression.descriptor->fold_case || context.fold_name_case || expression.case_fold) ? FNM_CASEFOLD : 0; - return MatchesPreparedGlob(expression, operand, context.visit.path, flags); + return MatchNativeGlob(expression, context, [&](int flags) { + return MatchesPreparedGlob(expression, operand, context.visit.path, flags); + }); } PreparedOperand PrepareTypeOperand(std::string_view argument) { @@ -4028,8 +4056,15 @@ void PreviewExecution(const parser::Expr& expr, const EvalContext& context) { context.emit(preview); } -template -EvaluationResult EvaluatePredicateResult(Cursor cursor, EvalContext& context) { +// Ordinary expressions need only truth and failure. Keep their recursive return value in +// registers instead of transporting score and deferred-node storage through every operator. +struct BooleanResult { + bool matched = false; + bool unknown = false; +}; + +template +Result EvaluatePredicateResult(Cursor cursor, EvalContext& context) { const auto& expr = cursor.Get(); const bool invalidate = !expr.descriptor->pure || expr.descriptor->kind == registry::Kind::kAction; if (invalidate) { @@ -4046,20 +4081,72 @@ EvaluationResult EvaluatePredicateResult(Cursor cursor, EvalContext& context) { return {.unknown = true}; } if (expr.descriptor->control == registry::Control::kTop) { - return EvaluateTop(expr, context); + if constexpr (std::is_same_v) { + return EvaluateTop(expr, context); + } else { + return {}; // The boolean evaluator is selected only without deferred state. + } } if (expr.descriptor->control == registry::Control::kShardStatus) { - return EvaluateShardStatus(expr, context); + if constexpr (std::is_same_v) { + return EvaluateShardStatus(expr, context); + } else { + return {}; + } } const bool matched = cursor.Predicate(context); - if (!context.control.output_error.ok()) { + if (!context.control.output_error.ok() || !context.control.metadata_error.ok()) { return {.unknown = true}; } if (invalidate) { // An action may read fields before mutating this same file through its sink. context.content.Invalidate(); } - return {.fuzzy = context.fuzzy_score.has_value() ? *context.fuzzy_score : std::nullopt, .matched = matched}; + if constexpr (std::is_same_v) { + return {.fuzzy = context.fuzzy_score.has_value() ? *context.fuzzy_score : std::nullopt, .matched = matched}; + } else { + return {.matched = matched}; + } +} + +template +BooleanResult EvaluateBoolean(Cursor cursor, EvalContext& context) { + using Kind = parser::Expr::Kind; + const Kind kind = cursor.Get().kind; + if (kind == Kind::kPredicate) { + return EvaluatePredicateResult(cursor, context); + } + const BooleanResult lhs = EvaluateBoolean(cursor.Left(), context); + if (lhs.unknown) { + return lhs; + } + switch (kind) { + case Kind::kNot: return {.matched = !lhs.matched}; + case Kind::kAnd: + case Kind::kNand: + if (!lhs.matched) { + return {.matched = kind == Kind::kNand}; + } + break; + case Kind::kOr: + case Kind::kNor: + if (lhs.matched) { + return {.matched = kind == Kind::kOr}; + } + break; + default: break; + } + const BooleanResult rhs = EvaluateBoolean(cursor.Right(), context); + if (rhs.unknown) { + return rhs; + } + switch (kind) { + case Kind::kNand: + case Kind::kNor: return {.matched = !rhs.matched}; + case Kind::kXor: return {.matched = lhs.matched != rhs.matched}; + case Kind::kXnor: return {.matched = lhs.matched == rhs.matched}; + default: return rhs; + } } template @@ -4085,6 +4172,15 @@ EvaluationResult EvaluateResult(Cursor cursor, EvalContext& context) { return {.matched = true}; } +template +EvaluationResult EvaluatePrepared(Cursor cursor, EvalContext& context) { + if (!context.fuzzy_score.has_value() && !context.deferred.has_value()) { + const BooleanResult result = EvaluateBoolean(cursor, context); + return {.matched = result.matched, .unknown = result.unknown}; + } + return EvaluateResult(cursor, context); +} + } // namespace struct BoundExpression::Cursor { @@ -4295,7 +4391,7 @@ absl::StatusOr PreparedExpression::Prepare(const parser::Exp EvaluationResult PreparedExpression::Evaluate(EvalContext& context) const { const Cursor::Environment environment{.data = *data_}; - const auto result = EvaluateResult(Cursor{.environment = environment, .node = data_->nodes.front()}, context); + const auto result = EvaluatePrepared(Cursor{.environment = environment, .node = data_->nodes.front()}, context); if (context.fuzzy_score.has_value()) { *context.fuzzy_score = result.fuzzy; } @@ -4538,7 +4634,7 @@ PreparedExpression::Worker PreparedExpression::MakeWorker(MatcherInitialization EvaluationResult PreparedExpression::Worker::Evaluate(EvalContext& context) const { const auto& environment = state_->environment; const auto result = - EvaluateResult(Cursor{.environment = environment, .node = environment.data.nodes.front()}, context); + EvaluatePrepared(Cursor{.environment = environment, .node = environment.data.nodes.front()}, context); if (context.fuzzy_score.has_value()) { *context.fuzzy_score = result.fuzzy; } diff --git a/xff/engine/evaluate.h b/xff/engine/evaluate.h index 8e1b6b1c7e5..108ddf74bf9 100644 --- a/xff/engine/evaluate.h +++ b/xff/engine/evaluate.h @@ -54,6 +54,10 @@ namespace xff::fuzzy { struct ScoreWorkspace; } // namespace xff::fuzzy +namespace xff::render { +class RawRecordBuffer; +} // namespace xff::render + namespace xff::engine { // Output sink for actions: receives one fully-formed record per action firing @@ -220,10 +224,14 @@ struct EvalContext { // FS-native name matching: when true, the case-sensitive name predicates // (-name/-path) fold case for this entry because it lives on a case-folding // volume and the xff-style default is in effect (no --exact). The driver - // resolves it per entry from a per-device IsCaseSensitive probe; it is always - // false in the find style and under --exact (byte-exact matching). The `i` - // variants (-iname/-ipath) fold regardless. + // supplies uniform answers directly and defers unknown native case to the resolver below; + // it is always false in the find style and under --exact (byte-exact matching). + // The `i` variants (-iname/-ipath) fold regardless. bool fold_name_case = false; + // Optional per-entry native-case resolution. A glob consults this only when its exact and + // folded answers differ; explicit folding and uniform filesystem answers need no lookup. + // A failed required metadata lookup records control.metadata_error before returning false. + std::optional> resolve_name_case; // The normalized 0..100 fuzzy quality composed across the expression for {fuzzy}, --sort=score, // and -top. Null when no consumer needs it; reset by the driver per entry. mbo::types::OptionalRef> fuzzy_score; @@ -315,6 +323,9 @@ struct EvalContext { // Empty - the default - keeps `-delete` a clean refusal on a member. mbo::types::OptionalRef> archive_deletions; ContentSnapshot content; + // Serial coordinator scratch for explicit path actions. The sink must consume the borrowed + // record before returning and must not re-enter this buffer. Unset callers use a local record. + mbo::types::OptionalRef path_records; }; // Evaluates a parsed find expression against one visited entry and returns its @@ -369,6 +380,8 @@ class BoundExpression final { // Bound tree with typed immutable operand pools. Source ownership follows // BoundExpression. Preparation performs no filesystem or account-database observations. +// Evaluation without scoring or deferred state uses compact boolean results internally; +// both paths share predicate effects, metadata checks, and failure handling. class PreparedExpression final { private: struct Data; diff --git a/xff/engine/expression_execution_test.cc b/xff/engine/expression_execution_test.cc index 45b3fbbf7ac..104e861a84a 100644 --- a/xff/engine/expression_execution_test.cc +++ b/xff/engine/expression_execution_test.cc @@ -270,6 +270,44 @@ TEST_P(ExpressionExecutionTest, SelectionOutputSummariesAndComparisonPreserveThe } } +TEST_P(ExpressionExecutionTest, BooleanOperatorsPreserveTruthAndReachedOutput) { + constexpr auto kOperators = std::to_array({"-a", "-o", "-nand", "-nor", "-xor", "-xnor", ","}); + for (const auto op : kOperators) { + for (const std::string_view left : {"-true", "-false"}) { + for (const std::string_view right : {"-true", "-false"}) { + Check({ + "root", + "(", + "(", + std::string(left), + "-printf", + "left\\n", + ")", + std::string(op), + "(", + std::string(right), + "-printf", + "right\\n", + ")", + ")", + "-print0", + }); + } + } + } +} + +TEST_P(ExpressionExecutionTest, BooleanOperatorsNeverHideOrNegateMetadataFailure) { + constexpr auto kOperators = std::to_array({"-a", "-o", "-nand", "-nor", "-xor", "-xnor", ","}); + for (const auto op : kOperators) { + Check({"root", "-type", "f", "(", "-size", "+1c", std::string(op), "-printf", "unreachable\\n", ")"}, true, true); + const std::string left = op == "-o" || op == "-nor" ? "-false" : "-true"; + Check( + {"root", "-type", "f", "(", left, std::string(op), "-size", "+1c", ")", ",", "-printf", "later\\n"}, true, + true); + } +} + TEST_P(ExpressionExecutionTest, PreparedTemplatesKeepResolvedDefaultsAndConditionalFailures) { const std::vector> cases{ {"root", "-type", "f", "-cmp", "{path}"}, diff --git a/xff/engine/glob_evaluate_test.cc b/xff/engine/glob_evaluate_test.cc index 26d653ebba0..cb3c0651137 100644 --- a/xff/engine/glob_evaluate_test.cc +++ b/xff/engine/glob_evaluate_test.cc @@ -71,6 +71,20 @@ struct GlobEvaluateTest : ::testing::Test { EXPECT_THAT(worker.Evaluate(context).matched, Eq(expected)); EXPECT_THAT(worker.EvaluateIterative(context).matched, Eq(expected)); EXPECT_THAT(second_worker.Evaluate(context).matched, Eq(expected)); + int probes = 0; + const auto resolve = [&] { + ++probes; + return fold; + }; + context.fold_name_case = false; + context.resolve_name_case = resolve; + EXPECT_THAT(Evaluate(expression, context), Eq(expected)); + EXPECT_THAT(worker.Evaluate(context).matched, Eq(expected)); + EXPECT_THAT(worker.EvaluateIterative(context).matched, Eq(expected)); + EXPECT_THAT(second_worker.Evaluate(context).matched, Eq(expected)); + const bool differs = (::fnmatch(pattern.c_str(), text.c_str(), 0) == 0) + != (::fnmatch(pattern.c_str(), text.c_str(), FNM_CASEFOLD) == 0); + EXPECT_THAT(probes, Eq(!expression.descriptor->fold_case && differs ? 4 : 0)); } } } diff --git a/xff/engine/run.cc b/xff/engine/run.cc index 9594503c5e0..b417583a2c7 100644 --- a/xff/engine/run.cc +++ b/xff/engine/run.cc @@ -5842,6 +5842,7 @@ RunResult RunFindCore( emit(text); } }; + render::RawRecordBuffer action_records('\n'); std::optional raw_records; if (format == render::Format::kNul || (format == render::Format::kPlain && path_encoding == render::PathEncoding::kRaw && !colorize)) { @@ -6145,9 +6146,8 @@ RunResult RunFindCore( // Keep columns conservative: metadata-free tabular output still has an unresolved // multi-directory Linux cost. Qualify template admission separately. const bool listing_stat_metadata = !column_templates.empty() || (compiled_tmpl && compiled_tmpl->NeedsStatMetadata()); - const bool full_metadata = (fs_native_case && !uniform_native_case) || colorize || any_reduction - || matched_entry.has_value() || listing_stat_metadata || collections.Active() - || !deferred_nodes.empty(); + const bool full_metadata = colorize || any_reduction || matched_entry.has_value() || listing_stat_metadata + || collections.Active() || !deferred_nodes.empty(); // Template score collection is independent of filesystem metadata. Preserve the // previous output contract even when lexical/context fields avoid eager stats. const bool collect_fuzzy_score = @@ -6272,6 +6272,7 @@ RunResult RunFindCore( .now = now, .tz = tz, .control = control, + .path_records = action_records, }; if (output_evaluator) { output_evaluator->Evaluate(context); @@ -6379,17 +6380,24 @@ RunResult RunFindCore( Control control; std::vector captures; // -regex groups for this entry; consumed by gated -exec {0}..{N} std::map outputs; // -capture results for this entry; read by {capture.NAME} - // FS-native name matching: fold -name/-path case on a case-folding volume - // (xff style, no --exact). Probe each device once, defaulting to - // case-sensitive (byte-exact) on the miss and on any probe error. - bool fold_name_case = uniform_fold_name_case; - if (fs_native_case && !uniform_native_case) { + // Resolve native case only when a reached predicate needs the distinction. No device + // observation is required when exact and folded glob results already agree. + std::optional native_fold; + const auto resolve_name_case = [&] { + if (native_fold) { + return *native_fold; + } + control.metadata_error = visit.EnsureMetadata(); + if (!control.metadata_error.ok()) { + return false; + } auto [it, inserted] = case_sensitive_by_dev.try_emplace(visit.metadata.dev, true); if (inserted) { it->second = walk_fs.IsCaseSensitive(visit.path).value_or(true); } - fold_name_case = !it->second; - } + native_fold = !it->second; + return *native_fold; + }; // The entry's colour, from the one palette this run resolved: used by the plain listing below // and by -ls's name column, so the two cannot disagree about what a file looks like. const std::string_view entry_color = colorize ? palette.CodeFor( @@ -6420,7 +6428,10 @@ RunResult RunFindCore( .time_format = time_format, .zone_suffix = zone_suffix, .block_size = block_size, - .fold_name_case = fold_name_case, + .fold_name_case = uniform_fold_name_case, + .resolve_name_case = fs_native_case && !uniform_native_case + ? std::optional>(resolve_name_case) + : std::nullopt, .fuzzy_score = collect_fuzzy_score ? mbo::types::OptionalRef{fuzzy_score} : mbo::types::OptionalRef>{}, .fuzzy_workspace = fuzzy_workspace, @@ -6459,6 +6470,7 @@ RunResult RunFindCore( .mounts = mounted_containers, .archive_deletions = archive_delete ? mbo::types::OptionalRef{archive_deletions} : mbo::types::OptionalRef>{}, + .path_records = action_records, }; const EvaluationResult evaluated = serial_evaluator ? serial_evaluator->Evaluate(eval_context) : expression ? EvaluateDeferred(*expression, eval_context) @@ -6618,6 +6630,7 @@ RunResult RunFindCore( .mounts = mounted_containers, .archive_deletions = archive_delete ? mbo::types::OptionalRef{archive_deletions} : mbo::types::OptionalRef>{}, + .path_records = action_records, }; const EvaluationResult evaluated = serial_evaluator ? serial_evaluator->Evaluate(eval_context) : EvaluateDeferred(*expression, eval_context); diff --git a/xff/engine/run_test.cc b/xff/engine/run_test.cc index 0c49337faab..6154bff1475 100644 --- a/xff/engine/run_test.cc +++ b/xff/engine/run_test.cc @@ -1598,6 +1598,25 @@ TEST_F(RunTest, Print0EmitsNulTerminatedRecords) { EXPECT_THAT(RunExpr({"-name", "a.txt", "-print0"}), UnorderedElementsAre(Path("a.txt"))); } +TEST_F(RunTest, ExplicitPathActionsKeepWholeRecordsAndTerminatorsIndependentOfListingFormat) { + const std::vector expected{ + Path("a.txt") + '\0', Path("a.txt") + '\n', Path("b.md") + '\0', + Path("b.md") + '\n', Path("sub/c.txt") + '\0', Path("sub/c.txt") + '\n', + }; + for (const std::string_view format : {"--format=plain", "--format=nul", "--format=jsonl"}) { + SCOPED_TRACE(format); + ASSERT_OK_AND_ASSIGN( + const auto command, + parser::Parse({std::string(format), "--sort=dir", root_.string(), "-type", "f", "-print0", "-print"})); + std::vector records; + const auto result = RunFind( + command, fs_, [&](std::string_view record) { records.emplace_back(record); }, + [](std::string_view, absl::Status status) { EXPECT_THAT(status, IsOk()); }); + EXPECT_THAT(result.errors, Eq(0)); + EXPECT_THAT(records, Eq(expected)); + } +} + TEST_F(RunTest, MaxDepthLimitsDescent) { // -maxdepth 1: root + its direct children, but not sub/c.txt (depth 2). EXPECT_THAT( @@ -4183,6 +4202,148 @@ class CaseFoldFs : public vfs::FileSystem { std::string root_; }; +class NativeCaseProbeFs final : public CaseFoldFs { + public: + explicit NativeCaseProbeFs(bool folding) : CaseFoldFs("/fake"), folding_(folding) {} + + absl::StatusOr Stat(std::string_view path, bool follow) const override { + if (path != "/fake") { + ++file_stats_; + if (fail_metadata_) { + return absl::NotFoundError("entry disappeared"); + } + } + return CaseFoldFs::Stat(path, follow); + } + + absl::StatusOr IsCaseSensitive(std::string_view) const override { + ++case_probes_; + return !folding_; + } + + int FileStats() const { return file_stats_; } + + int CaseProbes() const { return case_probes_; } + + void DenyMetadata() { fail_metadata_ = true; } + + private: + mutable int file_stats_ = 0; + mutable int case_probes_ = 0; + bool fail_metadata_ = false; + const bool folding_; +}; + +struct NativeCaseRunTest : RunTest { + struct Result { + RunResult run; + std::string output; + std::vector errors; + }; + + static Result RunCase(const NativeCaseProbeFs& filesystem, const std::vector& expression) { + std::vector args{"--archive=none", "--color=never", "--sort=none", "/fake", "-type", "f"}; + args.insert(args.end(), expression.begin(), expression.end()); + const auto command = parser::Parse(args); + EXPECT_THAT(command, IsOk()); + Result result; + result.run = RunFind( + *command, filesystem, [&](std::string_view record) { result.output.append(record); }, + [&](std::string_view, absl::Status error) { result.errors.push_back(error); }, registry::Style::kXff); + return result; + } +}; + +TEST_F(NativeCaseRunTest, EqualGlobAnswersNeedNeitherMetadataNorCaseProbe) { + for (const bool folding : {false, true}) { + NativeCaseProbeFs filesystem(folding); + filesystem.DenyMetadata(); // An unused lookup must not become an error. + const auto matched = RunCase(filesystem, {"-name", "*.txt", "-print"}); + EXPECT_THAT(matched.output, EqualsText("/fake/Foo.txt\n")); + EXPECT_THAT(matched.run.errors, Eq(0)); + const auto missed = RunCase(filesystem, {"-name", "*.md", "-print"}); + EXPECT_THAT(missed.output, IsEmpty()); + EXPECT_THAT(missed.run.errors, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(0)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); + } +} + +TEST_F(NativeCaseRunTest, DifferentGlobAnswersResolveNativeCaseIncludingNegatedClasses) { + for (const bool folding : {false, true}) { + const NativeCaseProbeFs filesystem(folding); + const auto positive = RunCase(filesystem, {"-name", "foo.txt", "-print"}); + EXPECT_THAT(positive.output, EqualsText(folding ? "/fake/Foo.txt\n" : "")); + EXPECT_THAT(positive.run.errors, Eq(0)); + const auto negated = RunCase(filesystem, {"-name", "[!f]*", "-print"}); + EXPECT_THAT(negated.output, EqualsText(folding ? "" : "/fake/Foo.txt\n")); + EXPECT_THAT(negated.run.errors, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(2)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(2)); + } +} + +TEST_F(NativeCaseRunTest, ReachedNativePredicatesShareTheEntryCaseResolution) { + const NativeCaseProbeFs filesystem(true); + const auto result = RunCase(filesystem, {"-name", "foo.txt", "-path", "/FAKE/FOO.TXT", "-print"}); + EXPECT_THAT(result.output, EqualsText("/fake/Foo.txt\n")); + EXPECT_THAT(result.run.errors, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(1)); +} + +TEST_F(NativeCaseRunTest, CaseSensitiveResolutionIsAlsoCachedAcrossReachedPredicates) { + const NativeCaseProbeFs filesystem(false); + const auto result = RunCase(filesystem, {"(", "-name", "foo.txt", "-o", "-path", "/FAKE/FOO.TXT", ")", "-print"}); + EXPECT_THAT(result.output, IsEmpty()); + EXPECT_THAT(result.run.errors, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(1)); +} + +TEST_F(NativeCaseRunTest, RequiredNativeCaseMetadataFailureCannotBeNegatedIntoAMatch) { + NativeCaseProbeFs filesystem(true); + filesystem.DenyMetadata(); + const auto result = RunCase(filesystem, {"!", "-name", "foo.txt", "-print"}); + EXPECT_THAT(result.output, IsEmpty()); + EXPECT_THAT(result.run.errors, Eq(1)); + EXPECT_THAT(result.errors, ElementsAre(StatusIs(absl::StatusCode::kNotFound, HasSubstr("disappeared")))); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); +} + +TEST_F(NativeCaseRunTest, ExplicitFoldingDoesNotResolveNativeCase) { + NativeCaseProbeFs filesystem(false); + filesystem.DenyMetadata(); + const auto result = RunCase(filesystem, {"-iname", "foo.txt", "-print"}); + EXPECT_THAT(result.output, EqualsText("/fake/Foo.txt\n")); + EXPECT_THAT(result.run.errors, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(0)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); +} + +TEST_F(NativeCaseRunTest, NativeFuzzyMatchingStillResolvesCaseWhenReached) { + for (const bool folding : {false, true}) { + const NativeCaseProbeFs filesystem(folding); + const auto result = RunCase(filesystem, {"-fuzzy", "Foo", "-print"}); + EXPECT_THAT(result.output, EqualsText("/fake/Foo.txt\n")); + EXPECT_THAT(result.run.errors, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(1)); + } +} + +TEST_F(NativeCaseRunTest, NativeFuzzyMetadataFailureCannotBeNegatedIntoAMatch) { + NativeCaseProbeFs filesystem(true); + filesystem.DenyMetadata(); + const auto result = RunCase(filesystem, {"!", "-fuzzy", "Foo", "-print"}); + EXPECT_THAT(result.output, IsEmpty()); + EXPECT_THAT(result.run.errors, Eq(1)); + EXPECT_THAT(result.errors, ElementsAre(StatusIs(absl::StatusCode::kNotFound, HasSubstr("disappeared")))); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); +} + // Runs `-name ` over a CaseFoldFs (holding Foo.txt) in `style`, with or // without --exact, and returns the concatenated emitted output. std::string RunNameOnCaseFoldVolume(std::string_view pattern, std::optional style, bool exact) { diff --git a/xff/engine/uniform_case_test.cc b/xff/engine/uniform_case_test.cc index 18add4cc023..19f41dce344 100644 --- a/xff/engine/uniform_case_test.cc +++ b/xff/engine/uniform_case_test.cc @@ -209,7 +209,9 @@ TEST_F(UniformCaseTest, MixedDevicesCacheAnswersAndErrorsInOrdinaryAndDeferredPa result.output, EqualsText("/fixture/Foo0.TXT\n/fixture/Foo3.txt\n/fixture/Foo4.txt\n/fixture/Foo5.TXT\n")); EXPECT_THAT(result.diagnostics, IsEmpty()); EXPECT_THAT(result.result.errors, Eq(0)); - EXPECT_THAT(result.case_paths, ElementsAre("/fixture", "/fixture/Foo1.TXT", "/fixture/Foo2.TXT")); + // The directory fails -type f before native-case matching; each device is probed at its + // first reached leaf. Repeated sensitive, insensitive, and failed answers stay cached. + EXPECT_THAT(result.case_paths, ElementsAre("/fixture/Foo0.TXT", "/fixture/Foo1.TXT", "/fixture/Foo2.TXT")); EXPECT_THAT(result.case_queries, Eq(3)); } } diff --git a/xff/engine/walk.cc b/xff/engine/walk.cc index c56a84235ea..9d07360216c 100644 --- a/xff/engine/walk.cc +++ b/xff/engine/walk.cc @@ -1024,14 +1024,19 @@ class Walker { // This buffer is local to a listing. Nested directory visits cannot invalidate it; // queued consumers already snapshot Visit's callback-bounded path observation. std::string path_scratch; + std::size_t prefix_size = std::string::npos; const auto visit_child = [&](const Stated& child, bool dived = false) { if (!child.path.empty()) { return VisitOne(child, batch.lazy, depth, dived); } - path_scratch.assign(directory); - if (!path_scratch.empty() && path_scratch.back() != '/') { - path_scratch.push_back('/'); + if (prefix_size == std::string::npos) { + path_scratch.assign(directory); + if (!path_scratch.empty() && path_scratch.back() != '/') { + path_scratch.push_back('/'); + } + prefix_size = path_scratch.size(); } + path_scratch.resize(prefix_size); path_scratch.append(child.name); return VisitOne(child, batch.lazy, depth, false, path_scratch); }; diff --git a/xff/engine/walk_test.cc b/xff/engine/walk_test.cc index 8d1a2449e71..53ec1cfb7ec 100644 --- a/xff/engine/walk_test.cc +++ b/xff/engine/walk_test.cc @@ -332,6 +332,35 @@ TEST_F(NameListingTest, MatchesCompletePathsAcrossOrderingDepthLinksAndWorkers) } } +TEST_F(NameListingTest, SharedPrefixSurvivesGrowingAndShrinkingEntryNames) { + NameListingFs filesystem(true); + const std::string root = "/another_directory_prefix_longer_than_small_string_storage"; + const std::vector names{std::string(160, 'a'), "b", std::string(320, 'c'), "d"}; + std::vector children; + std::vector expected{root}; + for (const auto& name : names) { + const std::string path = absl::StrCat(root, "/", name); + children.push_back(FileEntry(path, name)); + filesystem.AddFile(path, 1); + expected.push_back(path); + } + filesystem.AddDir(root, 1, std::move(children)); + const auto roots = std::to_array({root}); + std::vector paths; + EXPECT_THAT( + Walk( + filesystem, roots, {.sort = SortOrder::kNone, .metadata = MetadataDemand::kOnDemand}, + [&](const Visit& visit) { + EXPECT_THAT(visit.EnsureMetadata(), IsOk()); + paths.emplace_back(visit.path); + return WalkAction::kContinue; + }, + [](std::string_view, absl::Status status) { EXPECT_THAT(status, IsOk()); }), + IsOk()); + EXPECT_THAT(paths, Eq(expected)); + EXPECT_THAT(filesystem.NameReadCount(), Eq(1)); +} + TEST_F(NameListingTest, RootOnlyArchiveCallbackDoesNotDisableChildNames) { const NameListingFs filesystem(true); const auto roots = std::to_array({"/a_directory_prefix_longer_than_small_string_storage"}); diff --git a/xff/presentation/render/record_buffer.h b/xff/presentation/render/record_buffer.h index 1cb73bbefaa..680b0cd53ed 100644 --- a/xff/presentation/render/record_buffer.h +++ b/xff/presentation/render/record_buffer.h @@ -26,8 +26,14 @@ class RawRecordBuffer final { template Consumer> void EmitRecord(std::string_view path, Consumer&& consume) { + EmitRecord(path, terminator_, std::forward(consume)); + } + + // Explicit actions can alternate newline and NUL records while retaining the same storage. + template Consumer> + void EmitRecord(std::string_view path, char terminator, Consumer&& consume) { // XFF_ABI_POINTER: std::string::resize_and_overwrite requires a writable buffer callback. - bytes_.resize_and_overwrite(path.size() + 1, [path, terminator = terminator_](char* data, std::size_t) noexcept { + bytes_.resize_and_overwrite(path.size() + 1, [path, terminator](char* data, std::size_t) noexcept { const std::span record(data, path.size() + 1); std::ranges::copy(path, record.begin()); record.back() = terminator; diff --git a/xff/presentation/render/record_buffer_test.cc b/xff/presentation/render/record_buffer_test.cc index 708e70b70c8..a442a208702 100644 --- a/xff/presentation/render/record_buffer_test.cc +++ b/xff/presentation/render/record_buffer_test.cc @@ -47,6 +47,23 @@ TEST_F(RawRecordBufferTest, QueuedConsumersKeepIndependentRecords) { EXPECT_THAT(rows, ElementsAre(EqualsText("first\n"), EqualsText(std::string(160, 'x') + "\n"), EqualsText("last\n"))); } +TEST_F(RawRecordBufferTest, ExplicitTerminatorsAlternateWithoutChangingTheDefault) { + RawRecordBuffer buffer('\n'); + std::vector rows; + const auto keep = [&](std::string_view text) { rows.emplace_back(text); }; + const std::string long_path(160, 'x'); + buffer.EmitRecord(long_path, '\0', keep); + const auto grown = buffer.RetainedCapacity(); + buffer.EmitRecord("short", '\n', keep); + buffer.EmitRecord("another", '\0', keep); + buffer.EmitRecord("default", keep); + EXPECT_THAT(buffer.RetainedCapacity(), Ge(grown)); + EXPECT_THAT( + rows, ElementsAre( + EqualsText(long_path + '\0'), EqualsText("short\n"), EqualsText(std::string("another\0", 8)), + EqualsText("default\n"))); +} + TEST_F(RawRecordBufferTest, RetainsUsefulCapacityButReleasesOversizedRecordsAfterConsumption) { RawRecordBuffer buffer('\n'); const auto consume = [](std::string_view) {}; diff --git a/xff_extras_api/archive_backend.cc b/xff_extras_api/archive_backend.cc index 0166fec8cff..962554fc6c0 100644 --- a/xff_extras_api/archive_backend.cc +++ b/xff_extras_api/archive_backend.cc @@ -17,8 +17,10 @@ #include #include +#include #include #include +#include #include #include #include @@ -76,11 +78,6 @@ std::vector& ReadFormatsSlot() { return slot; } -absl::flat_hash_set& GateSuffixesSlot() { - static absl::flat_hash_set slot; - return slot; -} - std::vector AllReadFormats() { std::vector formats = ReadFormatsSlot(); for (const ContainerReader& reader : ContainerReadersSlot()) { @@ -89,15 +86,49 @@ std::vector AllReadFormats() { return formats; } -void RebuildGate() { - absl::flat_hash_set& gate = GateSuffixesSlot(); - gate.clear(); - for (const ReadFormatInfo& format : AllReadFormats()) { - for (const std::string& suffix : format.suffixes) { - const std::string::size_type dot = suffix.rfind('.'); - gate.insert(absl::AsciiStrToLower(dot == 0 ? suffix : suffix.substr(dot))); +absl::flat_hash_set BuildGate() { + absl::flat_hash_set gate; + const auto include = [&gate](absl::Span formats) { + for (const ReadFormatInfo& format : formats) { + for (const std::string& suffix : format.suffixes) { + const std::string::size_type dot = suffix.rfind('.'); + gate.insert(absl::AsciiStrToLower(std::string_view(suffix).substr(dot))); + } } + }; + include(ReadFormatsSlot()); + for (const ContainerReader& reader : ContainerReadersSlot()) { + include(reader.formats); } + return gate; +} + +// Registrations precede concurrent registry use. Only first-use construction needs a lock; +// subsequent name checks read the immutable set after its release/acquire publication. +class NameGate final { + public: + void Invalidate() { ready_.store(false, std::memory_order_release); } + + bool Contains(std::string_view suffix) { + if (!ready_.load(std::memory_order_acquire)) { + const std::scoped_lock lock(mutex_); + if (!ready_.load(std::memory_order_relaxed)) { + suffixes_ = BuildGate(); + ready_.store(true, std::memory_order_release); + } + } + return suffixes_.contains(absl::AsciiStrToLower(suffix)); + } + + private: + std::atomic ready_ = false; + std::mutex mutex_; + absl::flat_hash_set suffixes_; +}; + +NameGate& GateSlot() { + static NameGate slot; + return slot; } // The process-wide member remover, empty when no backend registered one - which is the answer for a @@ -153,7 +184,7 @@ void RegisterContainerReader( found->formats = std::move(formats); } std::ranges::sort(readers, {}, &ContainerReader::name); - RebuildGate(); + GateSlot().Invalidate(); } void RegisterContainerMemberRemover(ContainerMemberRemover remover) { @@ -302,7 +333,7 @@ absl::Status PackContainer(std::string_view path, const std::vector& f void RegisterContainerReadFormats(std::vector formats) { ReadFormatsSlot() = std::move(formats); - RebuildGate(); + GateSlot().Invalidate(); } std::vector ContainerReadFormats() { @@ -320,7 +351,7 @@ bool LooksLikeContainerName(std::string_view name) { // `.gz` is a dotfile, not a gzip called something. return false; } - return GateSuffixesSlot().contains(absl::AsciiStrToLower(name.substr(dot))); + return GateSlot().Contains(name.substr(dot)); } absl::StatusOr> OpenContainer(std::string_view container, MemberPathOptions options) { diff --git a/xff_extras_api/archive_backend.h b/xff_extras_api/archive_backend.h index 0438619e5d4..e257191d352 100644 --- a/xff_extras_api/archive_backend.h +++ b/xff_extras_api/archive_backend.h @@ -75,6 +75,8 @@ struct ReadFormatInfo { // first. InvalidArgument means "not my format" and falls through; every other status is the reader's // definitive answer. Passing an empty opener removes that name, which keeps tests able to restore the // process-wide registry. +// Register before concurrent registry use; replacement/removal requires all readers to be idle. +// The suffix lookup is built on first use after registration, without copying format descriptions. void RegisterContainerReader( std::string name, ContainerOpener opener, @@ -249,6 +251,7 @@ struct ContainerPackerRegistrar { // Installs the override opener's read-format vocabulary. Production extras register their formats // atomically with their opener through RegisterContainerReader. +// Like reader registration, this requires all registry readers to be idle. void RegisterContainerReadFormats(std::vector formats); // The read formats the linked backend declared, in its own (documentation) order. Empty when no diff --git a/xff_extras_api/archive_backend_test.cc b/xff_extras_api/archive_backend_test.cc index f3b26118be0..7c0b7068b03 100644 --- a/xff_extras_api/archive_backend_test.cc +++ b/xff_extras_api/archive_backend_test.cc @@ -16,10 +16,12 @@ #include "xff/archive/archive_backend.h" #include +#include #include #include #include #include +#include #include #include "absl/status/status.h" @@ -37,6 +39,7 @@ using ::mbo::testing::IsOk; using ::mbo::testing::IsOkAndHolds; using ::mbo::testing::StatusIs; using ::testing::AllOf; +using ::testing::Each; using ::testing::ElementsAre; using ::testing::Eq; using ::testing::Field; @@ -85,6 +88,7 @@ struct ArchiveBackendTest : ::testing::Test { RegisterContainerOpener(ContainerOpener()); RegisterContainerReader("test-a", ContainerOpener(), {}); RegisterContainerReader("test-b", ContainerOpener(), {}); + RegisterContainerReadFormats({}); RegisterContainerMemberRemover(ContainerMemberRemover()); RegisterContainerPacker(ContainerPacker(), {}, {}); } @@ -295,6 +299,73 @@ TEST_F(ArchiveBackendTest, TheNameGateRejectsEverydayFiles) { RegisterContainerReadFormats({}); // reset for the other tests in this process } +TEST_F(ArchiveBackendTest, NameGateTracksReaderReplacementRemovalAndSharedSuffixes) { + const auto opener = [](std::string_view, std::optional, MemberPathOptions) { + return std::make_unique(); + }; + RegisterContainerReader("test-a", opener, {{.name = "a", .suffixes = {".a", ".shared"}}}); + RegisterContainerReader("test-b", opener, {{.name = "b", .suffixes = {".b", ".shared"}}}); + EXPECT_THAT(LooksLikeContainerName("one.a"), IsTrue()); + EXPECT_THAT(LooksLikeContainerName("one.shared"), IsTrue()); + + RegisterContainerReader("test-a", opener, {{.name = "replacement", .suffixes = {".new"}}}); + EXPECT_THAT(LooksLikeContainerName("one.a"), IsFalse()); + EXPECT_THAT(LooksLikeContainerName("one.new"), IsTrue()); + EXPECT_THAT(LooksLikeContainerName("one.shared"), IsTrue()); + + RegisterContainerReader("test-b", {}, {}); + EXPECT_THAT(LooksLikeContainerName("one.b"), IsFalse()); + EXPECT_THAT(LooksLikeContainerName("one.shared"), IsFalse()); + EXPECT_THAT(LooksLikeContainerName("one.NEW"), IsTrue()); + RegisterContainerReader("test-a", {}, {}); + EXPECT_THAT(LooksLikeContainerName("one.new"), IsFalse()); +} + +TEST_F(ArchiveBackendTest, NameGateCombinesOverrideVocabularyWithReaderVocabulary) { + RegisterContainerReader( + "test-a", + [](std::string_view, std::optional, MemberPathOptions) { + return std::make_unique(); + }, + {{.name = "a", .suffixes = {".a"}}}); + EXPECT_THAT(LooksLikeContainerName("one.a"), IsTrue()); + EXPECT_THAT(LooksLikeContainerName("one.zip"), IsFalse()); + RegisterContainerReadFormats({{.name = "zip", .suffixes = {".zip"}}}); + EXPECT_THAT(LooksLikeContainerName("one.a"), IsTrue()); + EXPECT_THAT(LooksLikeContainerName("one.zip"), IsTrue()); + RegisterContainerReadFormats({{.name = "tar", .suffixes = {".tar.gz"}}}); + EXPECT_THAT(LooksLikeContainerName("one.zip"), IsFalse()); + EXPECT_THAT(LooksLikeContainerName("one.tar.GZ"), IsTrue()); + RegisterContainerReadFormats({}); + EXPECT_THAT(LooksLikeContainerName("one.tar.gz"), IsFalse()); + EXPECT_THAT(LooksLikeContainerName("one.a"), IsTrue()); +} + +TEST_F(ArchiveBackendTest, NameGateSupportsConcurrentFirstQueriesAfterRegistration) { + RegisterContainerReadFormats({{.name = "zip", .suffixes = {".zip", ".jar"}}}); + std::array matches{}; + std::latch ready(matches.size()); + std::latch start(1); + std::vector workers; + workers.reserve(matches.size()); + for (bool& match : matches) { + workers.emplace_back([&match, &ready, &start] { + ready.count_down(); + start.wait(); + bool correct = true; + for (int repeat = 0; repeat < 100; ++repeat) { + correct = correct && LooksLikeContainerName("one.ZIP") && LooksLikeContainerName("two.jar") + && !LooksLikeContainerName("plain.txt"); + } + match = correct; + }); + } + ready.wait(); + start.count_down(); + workers.clear(); // Join before checking results or allowing registry teardown. + EXPECT_THAT(matches, Each(IsTrue())); +} + TEST_F(ArchiveBackendTest, ARegisteredOpenerIsUsedAndSeesTheMemberPathOptions) { // The options must reach the backend, or a container opened during a run would render member paths // with the default separator instead of the one the user asked for.
Version
Commit
PR / ReleaseNot available
Revision date