From 2866df5a6d983e01a0cb6f0375e26ebda95312af Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 12:46:05 +0000 Subject: [PATCH 01/20] Qualify extended production benchmark workloads across historical builds --- docs/benchmark-chart-sensitivity-audit.md | 135 +++ docs/benchmark-correctness-audit.md | 7 + docs/benchmark-extended-history-campaign.md | 125 +++ .../chart-sensitivity-audit-20261107.json | 310 +++++++ .../extended-history-revisions-20261107.json | 782 ++++++++++++++++++ ...xtended-history-viewer-check-20261107.json | 34 + tools/BUILD.bazel | 92 +++ tools/benchmark_extended.py | 206 +++++ tools/benchmark_extended_build.py | 130 +++ tools/benchmark_extended_build_test.py | 44 + tools/benchmark_extended_history.py | 283 +++++++ tools/benchmark_extended_history_test.py | 71 ++ tools/benchmark_extended_report.py | 189 +++++ tools/benchmark_extended_report_test.py | 67 ++ tools/benchmark_extended_test.py | 106 +++ 15 files changed, 2581 insertions(+) create mode 100644 docs/benchmark-chart-sensitivity-audit.md create mode 100644 docs/benchmark-extended-history-campaign.md create mode 100644 docs/benchmarks/chart-sensitivity-audit-20261107.json create mode 100644 docs/benchmarks/extended-history-revisions-20261107.json create mode 100644 docs/benchmarks/extended-history-viewer-check-20261107.json create mode 100644 tools/benchmark_extended.py create mode 100644 tools/benchmark_extended_build.py create mode 100644 tools/benchmark_extended_build_test.py create mode 100644 tools/benchmark_extended_history.py create mode 100644 tools/benchmark_extended_history_test.py create mode 100644 tools/benchmark_extended_report.py create mode 100644 tools/benchmark_extended_report_test.py create mode 100644 tools/benchmark_extended_test.py 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..ee0c97e9d90 --- /dev/null +++ b/docs/benchmark-extended-history-campaign.md @@ -0,0 +1,125 @@ +# 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 physical CPU cores. 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. + +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. 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`. + +## 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. Historical build/measurement +collection is in progress; these functional checks establish no performance improvement. +Select CI workloads from completed results, retain the simple control, and report flat or +regressing cases alongside improvements. + +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-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/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..6eb5f00dd40 --- /dev/null +++ b/tools/benchmark_extended_report.py @@ -0,0 +1,189 @@ +#!/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 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 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']) + 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) + + +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 + name = 'xff-at-' + str(contract['anchor']['pr']) 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): + assets = output / 'assets' + assets.mkdir(exist_ok=True) + shutil.copyfile(renderer, assets / 'three-landscape.js') + catalog = [] + for view, title in [('traditional', 'Traditional tools'), ('anchor', f'Fixed XFF at PR #{contract["anchor"]["pr"]}')]: + 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) + catalog.append({'platform': 'Drogon / ' + contract['recipe'] + ' / ' + title, + 'platform_name': contract['platform'], 'dataset_type': contract['recipe'] + ' / ' + title, + 'commit': revision['sha'], 'date': revision['date'], + 'label': f'PR #{revision["pr"]} / {revision["sha"][:10]}', + 'source': 'merged', 'source_label': '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': [{'label': f'PR #{revision["pr"]}', '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': 'Drogon Linux extended qualification', 'platform_details': contract['platform']}) + (output / 'catalog.json').write_text(json.dumps(catalog, indent=2) + '\n') + intro = ('Extended benchmark history' + '' + '

Extended benchmark history

Independent extended suite; production full binaries on Linux tmpfs. ' + 'Each historical run is interleaved with the fixed current binary and a traditional tool. ' + f'{len(revisions)} complete revisions are shown, including regressions and unchanged controls.

') + (output / 'index.html').write_text(intro + landscape.history_panel(catalog) + '') + + +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) + 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', + 'contract_sha256': hashlib.sha256((root / 'contract.json').read_bytes()).hexdigest(), + 'endpoints': {str(revision['pr']): [row for row in rows if row['sha'] == revision['sha']] + for revision in (contract['revisions'][0], contract['revisions'][-1])}} + (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) + 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..494ebc16c9c --- /dev/null +++ b/tools/benchmark_extended_report_test.py @@ -0,0 +1,67 @@ +# 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 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, + 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) + + 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_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) + + +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() From 376562d698d97bd8181542e69d80ae837b6732c1 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 13:42:33 +0000 Subject: [PATCH 02/20] Expose benchmark CPU costs and retain historical build identities --- docs/benchmark-extended-history-campaign.md | 30 +- .../extended-history-builds-20261107.json | 1231 +++++++++++++++++ tools/benchmark_extended_report.py | 92 +- tools/benchmark_extended_report_test.py | 48 + 4 files changed, 1388 insertions(+), 13 deletions(-) create mode 100644 docs/benchmarks/extended-history-builds-20261107.json diff --git a/docs/benchmark-extended-history-campaign.md b/docs/benchmark-extended-history-campaign.md index ee0c97e9d90..cdd9426da47 100644 --- a/docs/benchmark-extended-history-campaign.md +++ b/docs/benchmark-extended-history-campaign.md @@ -87,9 +87,16 @@ python3.13 tools/benchmark_extended_report.py \ ``` 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. Serve -the report directory over HTTP for JSON fetches. `--allow-partial` is for monitoring; the default -refuses incomplete campaigns. +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 @@ -114,10 +121,21 @@ On `drogon.boerger.online`, the root is `/home/marcus/Documents/xff-chart-campai - `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. Historical build/measurement -collection is in progress; these functional checks establish no performance improvement. +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. + +Measurement collection is in progress. A separate endpoint repeat is queued after successful +completion: every one of the 60 predeclared cases at both endpoints, fresh tmpfs fixtures, +27 measured rounds retaining the fastest 21. It uses the same frozen production binaries and +does not select only favorable cases. The repeated data has its own contract and directory +(`confirmation/`) and must not be merged with the nine-round historical population. Before the +repeat, an independent pass rehashes all 130 retained binaries and their build/link evidence. Select CI workloads from completed results, retain the simple control, and report flat or -regressing cases alongside improvements. +regressing cases alongside improvements. A historical improvement alone does not establish that +XFF is competitive with its traditional reference. 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 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/tools/benchmark_extended_report.py b/tools/benchmark_extended_report.py index 6eb5f00dd40..ce8f7396840 100644 --- a/tools/benchmark_extended_report.py +++ b/tools/benchmark_extended_report.py @@ -60,13 +60,74 @@ def summarize_cell(row, contract): 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) + 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): @@ -96,12 +157,12 @@ def as_report(rows, contract, view): 'estimator': 'mean-fastest'}, 'tasks': tasks} -def export_viewer(output, contract, revisions, renderer): +def export_viewer(output, contract, revisions, renderer, incomplete=False): assets = output / 'assets' assets.mkdir(exist_ok=True) shutil.copyfile(renderer, assets / 'three-landscape.js') catalog = [] - for view, title in [('traditional', 'Traditional tools'), ('anchor', f'Fixed XFF at PR #{contract["anchor"]["pr"]}')]: + for view, title in [('traditional', 'Traditional tools'), ('anchor', f'XFF history (fixed PR #{contract["anchor"]["pr"]})')]: 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: @@ -125,12 +186,16 @@ def export_viewer(output, contract, revisions, renderer): 'reason': 'Clean historical source, configured production ThinLTO build, frozen executable hash checked before and after collection.'}, 'identity': 'Drogon Linux 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

Independent extended suite; production full binaries on Linux tmpfs. ' + '

Extended benchmark history

' + status + '

Independent extended suite; production full binaries on Linux tmpfs. ' 'Each historical run is interleaved with the fixed current binary and a traditional tool. ' - f'{len(revisions)} complete revisions are shown, including regressions and unchanged controls.

') - (output / 'index.html').write_text(intro + landscape.history_panel(catalog) + '') + f'{len(revisions)} complete revisions are shown, including regressions and unchanged controls.

' + '

The XFF history dataset compares the selected historical binary with the fixed current one. ' + 'Its current revision is an identical-binary control and should be near zero.

') + panel = landscape.history_panel(catalog).replace('', '') + (output / 'index.html').write_text(intro + panel + '') def main(): @@ -169,6 +234,17 @@ def main(): 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), @@ -176,12 +252,14 @@ def main(): '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': {str(revision['pr']): [row for row in rows if row['sha'] == revision['sha']] for revision in (contract['revisions'][0], contract['revisions'][-1])}} (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) + 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)) diff --git a/tools/benchmark_extended_report_test.py b/tools/benchmark_extended_report_test.py index 494ebc16c9c..7f178be8755 100644 --- a/tools/benchmark_extended_report_test.py +++ b/tools/benchmark_extended_report_test.py @@ -16,6 +16,8 @@ def row(self): '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)]]} @@ -31,6 +33,12 @@ def test_known_ratios_and_warmup_exclusion(self): 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_missing_duplicate_and_incorrect_samples_are_rejected(self): row = self.row() @@ -62,6 +70,46 @@ def test_renderer_adapter_does_not_invent_cells_or_mix_references(self): 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() From 48bfd5b623b1eb185056b7d104306d78c886c41c Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 15:56:31 +0000 Subject: [PATCH 03/20] Record verified 130-revision benchmark findings and complete previews --- docs/benchmark-extended-history-campaign.md | 104 ++- ...ended-history-complete-audit-20261107.json | 43 + .../extended-history-results-20261107.json | 832 ++++++++++++++++++ tools/benchmark_extended_report.py | 8 +- tools/benchmark_extended_report_test.py | 20 + tools/benchmark_landscape.py | 8 +- tools/benchmark_landscape_test.py | 8 + 7 files changed, 1008 insertions(+), 15 deletions(-) create mode 100644 docs/benchmarks/extended-history-complete-audit-20261107.json create mode 100644 docs/benchmarks/extended-history-results-20261107.json diff --git a/docs/benchmark-extended-history-campaign.md b/docs/benchmark-extended-history-campaign.md index cdd9426da47..ad9fa42a85c 100644 --- a/docs/benchmark-extended-history-campaign.md +++ b/docs/benchmark-extended-history-campaign.md @@ -22,7 +22,7 @@ is outside this investigation. | `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 physical CPU cores. Native tasks use +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. @@ -32,6 +32,12 @@ members without explicit directory entries. Fixture contents and metadata are ve 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 @@ -105,6 +111,60 @@ actions and records their hashes. XFF itself does not link ICU. The package SHA- `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`: @@ -127,15 +187,39 @@ completed before timing collection. The 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. -Measurement collection is in progress. A separate endpoint repeat is queued after successful -completion: every one of the 60 predeclared cases at both endpoints, fresh tmpfs fixtures, -27 measured rounds retaining the fastest 21. It uses the same frozen production binaries and -does not select only favorable cases. The repeated data has its own contract and directory -(`confirmation/`) and must not be merged with the nine-round historical population. Before the -repeat, an independent pass rehashes all 130 retained binaries and their build/link evidence. -Select CI workloads from completed results, retain the simple control, and report flat or -regressing cases alongside improvements. A historical improvement alone does not establish that -XFF is competitive with its traditional reference. +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 repeats all 60 cases for the candidate and an identical-baseline control, with +27 measured rounds retaining 21. It includes active-content workloads to detect added overhead. +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 [synthetic viewer check](benchmarks/extended-history-viewer-check-20261107.json) verifies both exported dataset views in Chromium. Both historical versions produce their exact expected 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/tools/benchmark_extended_report.py b/tools/benchmark_extended_report.py index ce8f7396840..d19857e50b0 100644 --- a/tools/benchmark_extended_report.py +++ b/tools/benchmark_extended_report.py @@ -193,8 +193,12 @@ def export_viewer(output, contract, revisions, renderer, incomplete=False): 'Each historical run is interleaved with the fixed current binary and a traditional tool. ' f'{len(revisions)} complete revisions are shown, including regressions and unchanged controls.

' '

The XFF history dataset compares the selected historical binary with the fixed current one. ' - 'Its current revision is an identical-binary control and should be near zero.

') - panel = landscape.history_panel(catalog).replace('', '') + 'Its current revision is an identical-binary control and should be near zero.

' + '

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 + '') diff --git a/tools/benchmark_extended_report_test.py b/tools/benchmark_extended_report_test.py index 7f178be8755..304571ce2d4 100644 --- a/tools/benchmark_extended_report_test.py +++ b/tools/benchmark_extended_report_test.py @@ -3,6 +3,8 @@ """Check historical ratios, paired uncertainty, and real-only renderer populations.""" import copy +from pathlib import Path +import tempfile import unittest import benchmark_extended_report as report @@ -40,6 +42,24 @@ def test_known_ratios_and_warmup_exclusion(self): 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)] diff --git a/tools/benchmark_landscape.py b/tools/benchmark_landscape.py index 5a2c9c82c76..8f56690e83e 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 ('
' '
' '
' @@ -466,8 +469,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) From 397b4a78054bce67e004f88d64c978d6f7d8907a Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 16:11:59 +0000 Subject: [PATCH 04/20] Link completed lazy-state investigation from benchmark campaign --- docs/benchmark-extended-history-campaign.md | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/docs/benchmark-extended-history-campaign.md b/docs/benchmark-extended-history-campaign.md index ad9fa42a85c..cf028b582fa 100644 --- a/docs/benchmark-extended-history-campaign.md +++ b/docs/benchmark-extended-history-campaign.md @@ -213,8 +213,16 @@ 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 repeats all 60 cases for the candidate and an identical-baseline control, with -27 measured rounds retaining 21. It includes active-content workloads to detect added overhead. +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. This is +a separately reviewable candidate on `benchmark/lazy-content-state-20261107`, with the tradeoff +documented in that branch's `docs/benchmarks/lazy-content-state-20261107.md`; it is not adopted by +the benchmark tooling branch. macOS whole-command performance and hash-heavy workloads have not +been qualified for this candidate. 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 From 6ac77f81b145445cbc1ac5b2aae5d41d594aeb74 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 15:15:01 +0000 Subject: [PATCH 05/20] Construct per-entry content cache state only when used --- xff/content/snapshot.cc | 34 ++++++++++++++-------------- xff/content/snapshot.h | 19 ++++++++++++---- xff/content/snapshot_test.cc | 43 ++++++++++++++++++++++++++++++++++++ 3 files changed, 76 insertions(+), 20 deletions(-) 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..c8453000780 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() : 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"); From 51f4b06ddd743ec1622789571477d987a89b930e Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 15:18:41 +0000 Subject: [PATCH 06/20] Preserve nonthrowing empty snapshot construction --- xff/content/snapshot.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xff/content/snapshot.h b/xff/content/snapshot.h index c8453000780..3efd6c844df 100644 --- a/xff/content/snapshot.h +++ b/xff/content/snapshot.h @@ -41,7 +41,7 @@ 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() : state_(std::nullopt) {} + 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) From 7430720d2ab5c56c76d6ab5e4cb26bda4ce8f545 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 16:11:38 +0000 Subject: [PATCH 07/20] Record lazy content-state production measurements and tradeoffs --- .../lazy-content-state-20261107.json | 1567 +++++++++++++++++ .../benchmarks/lazy-content-state-20261107.md | 121 ++ docs/design-parallel.md | 7 +- 3 files changed, 1693 insertions(+), 2 deletions(-) create mode 100644 docs/benchmarks/lazy-content-state-20261107.json create mode 100644 docs/benchmarks/lazy-content-state-20261107.md 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..9a39739cf98 --- /dev/null +++ b/docs/benchmarks/lazy-content-state-20261107.md @@ -0,0 +1,121 @@ +# Lazy inline content snapshot state (2026-11-07) + +## Conclusion + +The implementation reduces work in the production binary, with modest elapsed gains and a small +repeated counterexample. Keep it as a separately reviewable candidate on +`benchmark/lazy-content-state-20261107`; the benchmark tooling branch does not adopt it. Broad +100,000-file listing is about 1% faster in both populations, while broad metadata/date output is +about 0.5% slower in both. The result supports applying lazy inline state selectively, with explicit +size and active-use measurements, rather than replacing owning pointers throughout the codebase. + +## 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-parallel.md b/docs/design-parallel.md index f8103ebdec0..1304c5c189b 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 From 6c3cbac013649b271a0cc1528d7311001d4d0016 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 17:40:50 +0000 Subject: [PATCH 08/20] Adopt measured lazy content state optimization --- docs/benchmark-extended-history-campaign.md | 10 +++++----- docs/benchmarks/lazy-content-state-20261107.md | 18 ++++++++++++------ 2 files changed, 17 insertions(+), 11 deletions(-) diff --git a/docs/benchmark-extended-history-campaign.md b/docs/benchmark-extended-history-campaign.md index cf028b582fa..1f85187a0c7 100644 --- a/docs/benchmark-extended-history-campaign.md +++ b/docs/benchmark-extended-history-campaign.md @@ -218,11 +218,11 @@ experiment completed all 60 cases for the candidate and an identical-baseline co 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. This is -a separately reviewable candidate on `benchmark/lazy-content-state-20261107`, with the tradeoff -documented in that branch's `docs/benchmarks/lazy-content-state-20261107.md`; it is not adopted by -the benchmark tooling branch. macOS whole-command performance and hash-heavy workloads have not -been qualified for this candidate. +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 diff --git a/docs/benchmarks/lazy-content-state-20261107.md b/docs/benchmarks/lazy-content-state-20261107.md index 9a39739cf98..753a473f89f 100644 --- a/docs/benchmarks/lazy-content-state-20261107.md +++ b/docs/benchmarks/lazy-content-state-20261107.md @@ -2,12 +2,18 @@ ## Conclusion -The implementation reduces work in the production binary, with modest elapsed gains and a small -repeated counterexample. Keep it as a separately reviewable candidate on -`benchmark/lazy-content-state-20261107`; the benchmark tooling branch does not adopt it. Broad -100,000-file listing is about 1% faster in both populations, while broad metadata/date output is -about 0.5% slower in both. The result supports applying lazy inline state selectively, with explicit -size and active-use measurements, rather than replacing owning pointers throughout the codebase. +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 From c97326cdec67667233e671cdadbb9ea19d333154 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 18:28:45 +0000 Subject: [PATCH 09/20] Build archive suffix lookup on first use without copying format descriptions --- xff_extras_api/archive_backend.cc | 61 ++++++++++++++++------ xff_extras_api/archive_backend.h | 3 ++ xff_extras_api/archive_backend_test.cc | 70 ++++++++++++++++++++++++++ 3 files changed, 119 insertions(+), 15 deletions(-) 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..993188c8f2e 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,72 @@ 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; + for (std::size_t index = 0; index < matches.size(); ++index) { + workers.emplace_back([&, index] { + 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"); + } + matches.at(index) = 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. From bb5f0ddfafbd1e76c6dc9fb11bc3ccdf0c66192f Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 18:34:25 +0000 Subject: [PATCH 10/20] Use compact results for ordinary prepared expression evaluation --- docs/design-expression-program.md | 8 +++ xff/engine/evaluate.cc | 82 ++++++++++++++++++++++--- xff/engine/evaluate.h | 2 + xff/engine/expression_execution_test.cc | 38 ++++++++++++ 4 files changed, 123 insertions(+), 7 deletions(-) diff --git a/docs/design-expression-program.md b/docs/design-expression-program.md index b175f52fe68..b72a16c6975 100644 --- a/docs/design-expression-program.md +++ b/docs/design-expression-program.md @@ -775,6 +775,14 @@ 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. + 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/xff/engine/evaluate.cc b/xff/engine/evaluate.cc index 11fbc9bc9e2..15806051237 100644 --- a/xff/engine/evaluate.cc +++ b/xff/engine/evaluate.cc @@ -4028,8 +4028,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,10 +4053,18 @@ 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()) { @@ -4059,7 +4074,51 @@ EvaluationResult EvaluatePredicateResult(Cursor cursor, EvalContext& context) { // 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 +4144,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 +4363,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 +4606,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..8dca272e819 100644 --- a/xff/engine/evaluate.h +++ b/xff/engine/evaluate.h @@ -369,6 +369,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}"}, From bc116da15d1983c158729961e3106ea54559519e Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 18:38:08 +0000 Subject: [PATCH 11/20] Reuse coordinator record storage for explicit path output --- docs/design-expression-program.md | 7 +++++++ xff/engine/BUILD.bazel | 1 + xff/engine/evaluate.cc | 13 +++++++++++-- xff/engine/evaluate.h | 7 +++++++ xff/engine/run.cc | 4 ++++ xff/engine/run_test.cc | 19 +++++++++++++++++++ xff/presentation/render/record_buffer.h | 8 +++++++- xff/presentation/render/record_buffer_test.cc | 17 +++++++++++++++++ 8 files changed, 73 insertions(+), 3 deletions(-) diff --git a/docs/design-expression-program.md b/docs/design-expression-program.md index b72a16c6975..4e9924b4a62 100644 --- a/docs/design-expression-program.md +++ b/docs/design-expression-program.md @@ -783,6 +783,13 @@ dry-run previews, cache invalidation and output errors. Scoring or deferred cont general evaluator. This selection preserves source order and every boolean operator's short-circuit behavior; it performs no expression rewriting. +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/xff/engine/BUILD.bazel b/xff/engine/BUILD.bazel index b13db9a3009..6b3a7fa6f8e 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 15806051237..d1c8c6d9c91 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" @@ -2611,13 +2612,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; } diff --git a/xff/engine/evaluate.h b/xff/engine/evaluate.h index 8dca272e819..aaf5069aa0e 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 @@ -315,6 +319,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 diff --git a/xff/engine/run.cc b/xff/engine/run.cc index 45baeec097f..82a50e98d6a 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)) { @@ -6265,6 +6266,7 @@ RunResult RunFindCore( .now = now, .tz = tz, .control = control, + .path_records = action_records, }; if (output_evaluator) { output_evaluator->Evaluate(context); @@ -6452,6 +6454,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) @@ -6611,6 +6614,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..40b7ed621ca 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( + 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( 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) {}; From 5bcfcdac9399ddc0426df5d88c2b260fcfa378f0 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 18:40:53 +0000 Subject: [PATCH 12/20] Retain directory prefixes while visiting name-only entries --- xff/engine/walk.cc | 11 ++++++++--- xff/engine/walk_test.cc | 29 +++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 3 deletions(-) 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"}); From 7bf2d17518255e05330587a5054ffc4c1e5819b8 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 18:49:21 +0000 Subject: [PATCH 13/20] Keep unmerged qualification identities distinct in benchmark reports --- tools/benchmark_extended_report.py | 48 ++++++++++++++++++------- tools/benchmark_extended_report_test.py | 28 +++++++++++++++ 2 files changed, 63 insertions(+), 13 deletions(-) diff --git a/tools/benchmark_extended_report.py b/tools/benchmark_extended_report.py index d19857e50b0..7613d984130 100644 --- a/tools/benchmark_extended_report.py +++ b/tools/benchmark_extended_report.py @@ -7,6 +7,7 @@ from collections import defaultdict import csv import hashlib +import html import json import math from pathlib import Path @@ -19,6 +20,19 @@ 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): @@ -140,7 +154,9 @@ def as_report(rows, contract, view): if ((label == 'anchor' and view == 'traditional') or (label not in ('xff', 'anchor') and view == 'anchor')): continue - name = 'xff-at-' + str(contract['anchor']['pr']) if label == 'anchor' else label + 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']} @@ -162,7 +178,8 @@ def export_viewer(output, contract, revisions, renderer, incomplete=False): assets.mkdir(exist_ok=True) shutil.copyfile(renderer, assets / 'three-landscape.js') catalog = [] - for view, title in [('traditional', 'Traditional tools'), ('anchor', f'XFF history (fixed PR #{contract["anchor"]["pr"]})')]: + 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: @@ -173,27 +190,33 @@ def export_viewer(output, contract, revisions, renderer, incomplete=False): document = landscape.render(report, '', task_order=order).replace( '', '') (directory / (view + '.html')).write_text(document) - catalog.append({'platform': 'Drogon / ' + contract['recipe'] + ' / ' + title, + 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': f'PR #{revision["pr"]} / {revision["sha"][:10]}', - 'source': 'merged', 'source_label': 'Merged history', 'local': True, + 'label': label + (' / ' + revision.get('subject', '') if experiment else ' / ' + revision['sha'][:10]), + 'source': 'experiment' if experiment else 'merged', + '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': [{'label': f'PR #{revision["pr"]}', 'href': f'https://github.com/mboworks/xff/pull/{revision["pr"]}'}], + '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': 'Drogon Linux extended qualification', 'platform_details': contract['platform']}) + '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 Linux tmpfs. ' - 'Each historical run is interleaved with the fixed current binary and a traditional tool. ' + '

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 history dataset compares the selected historical binary with the fixed current one. ' - 'Its current revision is an identical-binary control and should be near zero.

' + '

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 experiments are labeled separately from merged PRs.

' '

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

') @@ -259,8 +282,7 @@ def main(): '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': {str(revision['pr']): [row for row in rows if row['sha'] == revision['sha']] - for revision in (contract['revisions'][0], contract['revisions'][-1])}} + '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') diff --git a/tools/benchmark_extended_report_test.py b/tools/benchmark_extended_report_test.py index 304571ce2d4..7a45b822330 100644 --- a/tools/benchmark_extended_report_test.py +++ b/tools/benchmark_extended_report_test.py @@ -3,6 +3,7 @@ """Check historical ratios, paired uncertainty, and real-only renderer populations.""" import copy +import json from pathlib import Path import tempfile import unittest @@ -70,6 +71,33 @@ def test_missing_duplicate_and_incorrect_samples_are_rejected(self): 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 */') + report.export_viewer(root, contract, [(candidate, rows)], renderer) + for item in json.loads((root / 'catalog.json').read_text()): + self.assertEqual(item['source'], 'experiment') + self.assertEqual(item['links'], []) + self.assertIn('Experiment candidate', 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])] From 3fee2a73241c6ebe0b2a8dbdffce5c02b048a23b Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 19:16:51 +0000 Subject: [PATCH 14/20] Resolve native filesystem case only when matching requires it --- docs/design-expression-program.md | 10 +++ xff/engine/evaluate.cc | 43 ++++++++---- xff/engine/evaluate.h | 10 ++- xff/engine/glob_evaluate_test.cc | 14 ++++ xff/engine/run.cc | 31 +++++---- xff/engine/run_test.cc | 106 ++++++++++++++++++++++++++++++ 6 files changed, 188 insertions(+), 26 deletions(-) diff --git a/docs/design-expression-program.md b/docs/design-expression-program.md index 4e9924b4a62..99f8ce1cb15 100644 --- a/docs/design-expression-program.md +++ b/docs/design-expression-program.md @@ -783,6 +783,16 @@ dry-run previews, cache invalidation and output errors. Scoring or deferred cont 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 diff --git a/xff/engine/evaluate.cc b/xff/engine/evaluate.cc index d1c8c6d9c91..e97c1ebe00d 100644 --- a/xff/engine/evaluate.cc +++ b/xff/engine/evaluate.cc @@ -976,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, 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); @@ -1071,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 @@ -3315,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( @@ -3326,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) { @@ -4076,7 +4095,7 @@ Result EvaluatePredicateResult(Cursor cursor, EvalContext& context) { } } 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) { diff --git a/xff/engine/evaluate.h b/xff/engine/evaluate.h index aaf5069aa0e..108ddf74bf9 100644 --- a/xff/engine/evaluate.h +++ b/xff/engine/evaluate.h @@ -224,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; 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 82a50e98d6a..11256364037 100644 --- a/xff/engine/run.cc +++ b/xff/engine/run.cc @@ -6143,9 +6143,8 @@ RunResult RunFindCore( for (std::size_t index = 0; index < deferred_nodes.size(); ++index) { deferred_node_order.emplace(deferred_nodes[index], index); } - const bool full_metadata = (fs_native_case && !uniform_native_case) || colorize || any_reduction - || matched_entry.has_value() || !column_templates.empty() || compiled_tmpl.has_value() - || collections.Active() || !deferred_nodes.empty(); + const bool full_metadata = colorize || any_reduction || matched_entry.has_value() || !column_templates.empty() + || compiled_tmpl.has_value() || collections.Active() || !deferred_nodes.empty(); options.metadata = full_metadata ? MetadataDemand::kAlways : expression.has_value() ? ExpressionMetadata(*expression) : MetadataDemand::kNever; @@ -6374,17 +6373,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( @@ -6415,7 +6421,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 = full_metadata || rank_by_score ? mbo::types::OptionalRef{fuzzy_score} : mbo::types::OptionalRef>{}, .fuzzy_workspace = fuzzy_workspace, diff --git a/xff/engine/run_test.cc b/xff/engine/run_test.cc index 40b7ed621ca..f4b5272fc1b 100644 --- a/xff/engine/run_test.cc +++ b/xff/engine/run_test.cc @@ -4202,6 +4202,112 @@ 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_; + } + + mutable int file_stats = 0; + mutable int case_probes = 0; + bool fail_metadata = false; + + private: + const bool folding_; +}; + +struct NativeCaseRunTest : RunTest { + struct Result { + RunResult run; + std::string output; + std::vector errors; + }; + + 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.fail_metadata = true; // 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.file_stats, Eq(0)); + EXPECT_THAT(filesystem.case_probes, 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.file_stats, Eq(2)); + EXPECT_THAT(filesystem.case_probes, 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.file_stats, Eq(1)); + EXPECT_THAT(filesystem.case_probes, Eq(1)); +} + +TEST_F(NativeCaseRunTest, RequiredNativeCaseMetadataFailureCannotBeNegatedIntoAMatch) { + NativeCaseProbeFs filesystem(true); + filesystem.fail_metadata = true; + 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.file_stats, Eq(1)); + EXPECT_THAT(filesystem.case_probes, Eq(0)); +} + +TEST_F(NativeCaseRunTest, ExplicitFoldingDoesNotResolveNativeCase) { + NativeCaseProbeFs filesystem(false); + filesystem.fail_metadata = true; + 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.file_stats, Eq(0)); + EXPECT_THAT(filesystem.case_probes, 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) { From 67e500a1485c1e2040f271b8228ce7d90e44ee4d Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 19:19:19 +0000 Subject: [PATCH 15/20] Select an available source in experiment-only benchmark viewers --- tools/benchmark_web/history.js | 10 ++++++++-- tools/benchmark_web/landscape.test.mjs | 17 ++++++++++++++++- 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/tools/benchmark_web/history.js b/tools/benchmark_web/history.js index 21074d64295..02f499c1260 100644 --- a/tools/benchmark_web/history.js +++ b/tools/benchmark_web/history.js @@ -267,8 +267,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..16940b6b2c1 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') + 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,18 @@ 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-control="platform"]').inputValue(), + "linux", + ); assert.deepEqual(errors, []); } finally { await browser.close(); From 101ff84cf14ddd03cef4a3382a602672ff140be7 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 19:33:54 +0000 Subject: [PATCH 16/20] Retain basic-operation qualification and native-case regressions --- docs/benchmark-extended-history-campaign.md | 10 + .../find-listing-optimization-20261107.json | 5608 +++++++++++++++++ .../find-listing-optimization-20261107.md | 278 + xff/engine/run_test.cc | 31 + 4 files changed, 5927 insertions(+) create mode 100644 docs/benchmarks/find-listing-optimization-20261107.json create mode 100644 docs/benchmarks/find-listing-optimization-20261107.md diff --git a/docs/benchmark-extended-history-campaign.md b/docs/benchmark-extended-history-campaign.md index 1f85187a0c7..9cf393f59e7 100644 --- a/docs/benchmark-extended-history-campaign.md +++ b/docs/benchmark-extended-history-campaign.md @@ -229,6 +229,16 @@ population. Source, tests, build identities and samples live under `lazy-content 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 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..fae0f198d3e --- /dev/null +++ b/docs/benchmarks/find-listing-optimization-20261107.md @@ -0,0 +1,278 @@ +# 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. + +## 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. +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. diff --git a/xff/engine/run_test.cc b/xff/engine/run_test.cc index f4b5272fc1b..a8ccb737028 100644 --- a/xff/engine/run_test.cc +++ b/xff/engine/run_test.cc @@ -4287,6 +4287,15 @@ TEST_F(NativeCaseRunTest, ReachedNativePredicatesShareTheEntryCaseResolution) { EXPECT_THAT(filesystem.case_probes, 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.file_stats, Eq(1)); + EXPECT_THAT(filesystem.case_probes, Eq(1)); +} + TEST_F(NativeCaseRunTest, RequiredNativeCaseMetadataFailureCannotBeNegatedIntoAMatch) { NativeCaseProbeFs filesystem(true); filesystem.fail_metadata = true; @@ -4308,6 +4317,28 @@ TEST_F(NativeCaseRunTest, ExplicitFoldingDoesNotResolveNativeCase) { EXPECT_THAT(filesystem.case_probes, 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.file_stats, Eq(1)); + EXPECT_THAT(filesystem.case_probes, Eq(1)); + } +} + +TEST_F(NativeCaseRunTest, NativeFuzzyMetadataFailureCannotBeNegatedIntoAMatch) { + NativeCaseProbeFs filesystem(true); + filesystem.fail_metadata = true; + 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.file_stats, Eq(1)); + EXPECT_THAT(filesystem.case_probes, 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) { From 5ee7483f3e71325df76b4b1c8a6b6e5142545f34 Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 19:46:47 +0000 Subject: [PATCH 17/20] Order experiment views from baseline to candidate and report three-core results --- .../find-listing-optimization-20261107.md | 36 +++++++++++++++++++ tools/benchmark_extended_report.py | 10 +++++- tools/benchmark_extended_report_test.py | 12 +++++-- tools/benchmark_landscape.py | 1 + tools/benchmark_web/history.js | 6 ++++ tools/benchmark_web/landscape.test.mjs | 7 +++- 6 files changed, 67 insertions(+), 5 deletions(-) diff --git a/docs/benchmarks/find-listing-optimization-20261107.md b/docs/benchmarks/find-listing-optimization-20261107.md index fae0f198d3e..aa33be10764 100644 --- a/docs/benchmarks/find-listing-optimization-20261107.md +++ b/docs/benchmarks/find-listing-optimization-20261107.md @@ -16,6 +16,27 @@ baseline on both Linux and macOS. None of these commits is presented as a merged 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 @@ -242,6 +263,10 @@ The reporting change keeps experimental endpoint summaries keyed by full source 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. @@ -276,3 +301,14 @@ populations. Local previews are served from port 56205 under `find-listing-combi `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/tools/benchmark_extended_report.py b/tools/benchmark_extended_report.py index 7613d984130..3ef7607b75e 100644 --- a/tools/benchmark_extended_report.py +++ b/tools/benchmark_extended_report.py @@ -174,6 +174,11 @@ def as_report(rows, contract, view): 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') @@ -197,6 +202,8 @@ def export_viewer(output, contract, revisions, renderer, incomplete=False): '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', @@ -216,7 +223,8 @@ def export_viewer(output, contract, revisions, renderer, incomplete=False): 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 experiments are labeled separately from merged PRs.

' + '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).

') diff --git a/tools/benchmark_extended_report_test.py b/tools/benchmark_extended_report_test.py index 7a45b822330..4d0650f3a02 100644 --- a/tools/benchmark_extended_report_test.py +++ b/tools/benchmark_extended_report_test.py @@ -88,11 +88,17 @@ def test_experiments_keep_distinct_endpoints_and_do_not_claim_merged_prs(self): root = Path(directory) renderer = root / 'renderer.js' renderer.write_text('/* renderer fixture */') - report.export_viewer(root, contract, [(candidate, rows)], renderer) - for item in json.loads((root / 'catalog.json').read_text()): + 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 candidate', item['label']) + self.assertIn('Experiment ' + item['commit'], item['label']) self.assertIn('Darwin', item['platform']) document = (root / 'index.html').read_text() self.assertNotIn('PR #0', document) diff --git a/tools/benchmark_landscape.py b/tools/benchmark_landscape.py index 8f56690e83e..514e80488ca 100644 --- a/tools/benchmark_landscape.py +++ b/tools/benchmark_landscape.py @@ -452,6 +452,7 @@ def history_panel(catalog, *, include_overview=True): 'Version
' '' '' + '' '' '' '' diff --git a/tools/benchmark_web/history.js b/tools/benchmark_web/history.js index 02f499c1260..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"; diff --git a/tools/benchmark_web/landscape.test.mjs b/tools/benchmark_web/landscape.test.mjs index 16940b6b2c1..d658ebe32cc 100644 --- a/tools/benchmark_web/landscape.test.mjs +++ b/tools/benchmark_web/landscape.test.mjs @@ -462,7 +462,7 @@ 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') +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)) `, @@ -867,6 +867,11 @@ experiments = [dict(row, source='experiment', source_label='Unmerged experiments 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", From b620b8dd7451194cc68673e4bdc69702efb5ac8e Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 20:00:52 +0000 Subject: [PATCH 18/20] Publish benchmark qualification pages and retained result files --- release-site.json | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) 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" } } From 828b18cf17d6e46f994a1b3a4d350c5ce83d1ded Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 20:25:21 +0000 Subject: [PATCH 19/20] Align native-case cache test with lazy leaf resolution --- xff/engine/uniform_case_test.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) 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)); } } From 3e19bc724cff12a9592aa9d4ce144559a08d9c8f Mon Sep 17 00:00:00 2001 From: helly25 <6420169+helly25@users.noreply.github.com> Date: Sat, 7 Nov 2026 21:09:29 +0000 Subject: [PATCH 20/20] Resolve complete native-case qualification lint findings --- xff/engine/evaluate.cc | 2 +- xff/engine/run_test.cc | 61 ++++++++++++++------------ xff_extras_api/archive_backend_test.cc | 7 +-- 3 files changed, 38 insertions(+), 32 deletions(-) diff --git a/xff/engine/evaluate.cc b/xff/engine/evaluate.cc index e97c1ebe00d..89bf71eca05 100644 --- a/xff/engine/evaluate.cc +++ b/xff/engine/evaluate.cc @@ -977,7 +977,7 @@ bool EvalFalse(const parser::Expr&, EvalContext&) { // 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, Matches&& matches) { +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); } diff --git a/xff/engine/run_test.cc b/xff/engine/run_test.cc index a8ccb737028..6154bff1475 100644 --- a/xff/engine/run_test.cc +++ b/xff/engine/run_test.cc @@ -1606,7 +1606,7 @@ TEST_F(RunTest, ExplicitPathActionsKeepWholeRecordsAndTerminatorsIndependentOfLi for (const std::string_view format : {"--format=plain", "--format=nul", "--format=jsonl"}) { SCOPED_TRACE(format); ASSERT_OK_AND_ASSIGN( - auto command, + const auto command, parser::Parse({std::string(format), "--sort=dir", root_.string(), "-type", "f", "-print0", "-print"})); std::vector records; const auto result = RunFind( @@ -4208,8 +4208,8 @@ class NativeCaseProbeFs final : public CaseFoldFs { absl::StatusOr Stat(std::string_view path, bool follow) const override { if (path != "/fake") { - ++file_stats; - if (fail_metadata) { + ++file_stats_; + if (fail_metadata_) { return absl::NotFoundError("entry disappeared"); } } @@ -4217,15 +4217,20 @@ class NativeCaseProbeFs final : public CaseFoldFs { } absl::StatusOr IsCaseSensitive(std::string_view) const override { - ++case_probes; + ++case_probes_; return !folding_; } - mutable int file_stats = 0; - mutable int case_probes = 0; - bool fail_metadata = false; + 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_; }; @@ -4236,7 +4241,7 @@ struct NativeCaseRunTest : RunTest { std::vector errors; }; - Result RunCase(const NativeCaseProbeFs& filesystem, const std::vector& expression) { + 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); @@ -4252,15 +4257,15 @@ struct NativeCaseRunTest : RunTest { TEST_F(NativeCaseRunTest, EqualGlobAnswersNeedNeitherMetadataNorCaseProbe) { for (const bool folding : {false, true}) { NativeCaseProbeFs filesystem(folding); - filesystem.fail_metadata = true; // An unused lookup must not become an error. + 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.file_stats, Eq(0)); - EXPECT_THAT(filesystem.case_probes, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(0)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); } } @@ -4273,8 +4278,8 @@ TEST_F(NativeCaseRunTest, DifferentGlobAnswersResolveNativeCaseIncludingNegatedC 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.file_stats, Eq(2)); - EXPECT_THAT(filesystem.case_probes, Eq(2)); + EXPECT_THAT(filesystem.FileStats(), Eq(2)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(2)); } } @@ -4283,8 +4288,8 @@ TEST_F(NativeCaseRunTest, ReachedNativePredicatesShareTheEntryCaseResolution) { 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.file_stats, Eq(1)); - EXPECT_THAT(filesystem.case_probes, Eq(1)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(1)); } TEST_F(NativeCaseRunTest, CaseSensitiveResolutionIsAlsoCachedAcrossReachedPredicates) { @@ -4292,29 +4297,29 @@ TEST_F(NativeCaseRunTest, CaseSensitiveResolutionIsAlsoCachedAcrossReachedPredic 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.file_stats, Eq(1)); - EXPECT_THAT(filesystem.case_probes, Eq(1)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(1)); } TEST_F(NativeCaseRunTest, RequiredNativeCaseMetadataFailureCannotBeNegatedIntoAMatch) { NativeCaseProbeFs filesystem(true); - filesystem.fail_metadata = 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.file_stats, Eq(1)); - EXPECT_THAT(filesystem.case_probes, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); } TEST_F(NativeCaseRunTest, ExplicitFoldingDoesNotResolveNativeCase) { NativeCaseProbeFs filesystem(false); - filesystem.fail_metadata = true; + 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.file_stats, Eq(0)); - EXPECT_THAT(filesystem.case_probes, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(0)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); } TEST_F(NativeCaseRunTest, NativeFuzzyMatchingStillResolvesCaseWhenReached) { @@ -4323,20 +4328,20 @@ TEST_F(NativeCaseRunTest, NativeFuzzyMatchingStillResolvesCaseWhenReached) { 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.file_stats, Eq(1)); - EXPECT_THAT(filesystem.case_probes, Eq(1)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(1)); } } TEST_F(NativeCaseRunTest, NativeFuzzyMetadataFailureCannotBeNegatedIntoAMatch) { NativeCaseProbeFs filesystem(true); - filesystem.fail_metadata = 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.file_stats, Eq(1)); - EXPECT_THAT(filesystem.case_probes, Eq(0)); + EXPECT_THAT(filesystem.FileStats(), Eq(1)); + EXPECT_THAT(filesystem.CaseProbes(), Eq(0)); } // Runs `-name ` over a CaseFoldFs (holding Foo.txt) in `style`, with or diff --git a/xff_extras_api/archive_backend_test.cc b/xff_extras_api/archive_backend_test.cc index 993188c8f2e..7c0b7068b03 100644 --- a/xff_extras_api/archive_backend_test.cc +++ b/xff_extras_api/archive_backend_test.cc @@ -347,8 +347,9 @@ TEST_F(ArchiveBackendTest, NameGateSupportsConcurrentFirstQueriesAfterRegistrati std::latch ready(matches.size()); std::latch start(1); std::vector workers; - for (std::size_t index = 0; index < matches.size(); ++index) { - workers.emplace_back([&, index] { + workers.reserve(matches.size()); + for (bool& match : matches) { + workers.emplace_back([&match, &ready, &start] { ready.count_down(); start.wait(); bool correct = true; @@ -356,7 +357,7 @@ TEST_F(ArchiveBackendTest, NameGateSupportsConcurrentFirstQueriesAfterRegistrati correct = correct && LooksLikeContainerName("one.ZIP") && LooksLikeContainerName("two.jar") && !LooksLikeContainerName("plain.txt"); } - matches.at(index) = correct; + match = correct; }); } ready.wait();
Version
Commit
PR / ReleaseNot available
Revision date