diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 81da4577..1c1d721a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2894,6 +2894,120 @@ jobs: [ "$rc" -ne 0 ] || { echo "FAIL: a broken candidate exited 0"; exit 1; } echo "OK: a broken candidate is a visible failure (exit $rc), never a Python rescue" + # #263-A — the performance measurement INSTRUMENT, calibrated. Not a + # baseline: this job proves the instrument stands up, on both platforms, and + # that it refuses to measure anything decisive before the D7 freeze. + # + # It publishes no engine comparison and can publish none: the harness holds + # one engine's samples per cell and refuses a report carrying a comparison + # key. What it asserts here is that the refusal is real, not that Rust is + # anything. + perf-instrument: + name: "#263-A measurement instrument (CALIBRATION_ONLY)" + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest] + runs-on: ${{ matrix.os }} + defaults: + run: + shell: bash + steps: + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 + with: + # The step 4 freeze controls read git objects at the frozen source + # commit and prove it is an ancestor of this head. A depth-1 checkout + # cannot answer either question, and those controls refuse rather than + # pass vacuously — so the history is the thing that makes them real. + fetch-depth: 0 + - uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4 + with: + dotnet-version: "8.0.x" + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 + with: + python-version: "3.13" + - uses: dtolnay/rust-toolchain@fa04a1451ff1842e2626ccb99004d0195b455a88 # master, 2026-07-10 + with: + toolchain: stable + - name: Build the production own-cli candidate + working-directory: rust + run: cargo build -p own-cli --release + - name: The instrument's own selftest (no measurement taken) + run: python scripts/perf_baseline.py --selftest + - name: The instrument controls (firewall, both identity domains, provenance) + run: python tests/test_perf_instrument.py + # The Round 7 apparatus is a classifier and a structural preflight, both + # exercisable without a clock. The exclusivity control is the one that + # matters: the preregistration's first outcome table let one dataset + # satisfy two contradictory verdicts, and nothing in the process that + # produced it would have noticed. + - name: Round 7 apparatus controls (outcome exclusivity, zero guard, B1-B4) + run: python tests/test_round7_apparatus.py + # The calibration policy is pure: no clock, no files, no randomness, and no + # constant values at all. It is step 2 of the ratified sequence, written + # before any training corpus exists, so every claim it makes is checkable + # here on both platforms and none of it needs a measurement. + - name: Calibration policy controls (no defaults, symmetry, exact fit) + run: python tests/test_calibration_policy.py + # Step 4 froze WHICH BYTES the policy is, and nothing else. These controls + # recompute that digest from git blobs at the frozen commit, and refuse the + # artifact outright if it ever grows a field that is not identity. + - name: Calibration policy freeze controls (step 4 digest identity) + run: python tests/test_calibration_freeze.py + # Step 5 records the five constants the owner chose, bound to the step 4 + # identity. The frozen implementation is the judge of its own ranges, so + # these controls hand it the committed pairs rather than re-stating them. + - name: Calibration design constants controls (step 5 ratified values) + run: python tests/test_calibration_constants.py + # Step 6 preregisters a training collection that has not happened. These + # controls prove the protocol is complete and bound, and that the scope + # combiner reads the frozen selector's own margin instead of copying it. + - name: Training preregistration controls (step 6 protocol + scope binding) + run: python tests/test_training_prereg.py + # Step 7 needs two dedicated measurement hosts that do not exist yet. This + # captures WHAT a machine is and never how fast it is: no clock, no resource + # observation, proved by walking the AST rather than the prose. It also + # proves the tool sits outside all three frozen source sets, so preparing + # step 7 cannot move a digest steps 4, 5 and 6 are already bound to. + - name: Step 7 environment capture controls (measurement-free identity manifest) + run: python tests/test_step7_envcapture.py + # The same tool run for real on this runner. It writes nothing, starts no + # clock, and is NOT a binding input: a hosted runner is not admissible for + # step 7, and the manifest records the runner and CI flag that say so. + - name: Step 7 environment capture selftest (writes nothing, starts nothing) + run: python scripts/step7/envcapture.py --selftest + # Plan mode builds the arms, preflights THOSE bytes, freezes their + # identities and fixes the execution order — then returns before the + # timing function is reachable. Linux only: the arms are ELF binaries. + - name: Round 7 runner — plan mode, no clock started + if: matrix.os == 'ubuntu-latest' + run: | + python scripts/round7/runner.py \ + --candidate "$PWD/rust/target/release/own-cli" \ + --plan --build-dir "$RUNNER_TEMP/round7-arms" \ + --out "$RUNNER_TEMP/round7-plan.json" + # Decisive workloads: availability and pins only. No clock, no resource + # sampling — this step is what "enumerated, hashed, availability-checked" + # looks like when it is the only thing permitted. + - name: Decisive workloads — non-timed structural smoke + run: python scripts/perf_baseline.py --smoke-decisive + # The timed legacy calibration pair USED TO RUN HERE, and it is gone while + # step 7 is closed. It started a real stopwatch, produced forty timed cells + # per platform on every push and uploaded them, which made the step 6 + # preregistration's own claim to take no new observation false on the very + # commit that made it. A preregistration that fixes "exactly one collection" + # while CI quietly gathers numbers every twelve minutes has built an + # epistemic side channel, whatever anyone intends to do with the output. + # + # What still proves the apparatus, all of it untimed: --selftest above, the + # instrument controls, the round 7 apparatus controls, the round 7 runner in + # plan mode, the decisive structural smoke, and the calibration policy, + # freeze, constants and training preregistration controls. + # + # training-no-incidental-measurement fails this suite if any workflow + # regains a path to a measurement entrypoint while the preregistration + # still records step 7 as unauthorised. + # P-014 Tier B: external-reference resolution. The SAME sample, run two ways, must give two # verdicts — proving the extractor binds a THIRD-PARTY event only when its DLL is referenced: # A (no refs) -> ObservableObject is an error type -> OWN050 (honest skip), no leak diff --git a/docs/evidence/calibration/p022-263a-design-constants.json b/docs/evidence/calibration/p022-263a-design-constants.json new file mode 100644 index 00000000..d03c8455 --- /dev/null +++ b/docs/evidence/calibration/p022-263a-design-constants.json @@ -0,0 +1,26 @@ +{ + "artifact": "p022-263a-calibration-design-constants", + "bound_measurement_harness_digest": "562a7f7232dad2f4c79c6adfe0e1e7e25680b4b6f3444d54824bf0405e3c14b3", + "bound_policy_implementation_digest": "c3068ed7fa880a7083866ead25fe8bf65c87889d242d8af1f7eee01582cd5cbf", + "constants": { + "G": [ + 1, + 10 + ], + "M": [ + 2, + 1 + ], + "N_ladder": [ + 5, + 15, + 45 + ], + "R_runs": 5, + "q": [ + 19, + 20 + ] + }, + "ratified_by": "owner" +} diff --git a/docs/evidence/calibration/p022-263a-policy-freeze.json b/docs/evidence/calibration/p022-263a-policy-freeze.json new file mode 100644 index 00000000..beebbc77 --- /dev/null +++ b/docs/evidence/calibration/p022-263a-policy-freeze.json @@ -0,0 +1,17 @@ +{ + "artifact": "p022-263a-calibration-policy-freeze", + "measurement_harness_digest": "562a7f7232dad2f4c79c6adfe0e1e7e25680b4b6f3444d54824bf0405e3c14b3", + "policy_implementation_digest": "c3068ed7fa880a7083866ead25fe8bf65c87889d242d8af1f7eee01582cd5cbf", + "policy_implementation_digest_framing": "sha256 over the source set ordered by the UTF-8 bytes of each repo-relative POSIX path. Each file contributes, with no header and no separator: its path byte length as an 8-byte big-endian unsigned integer, its path's exact UTF-8 bytes, its blob byte length as an 8-byte big-endian unsigned integer, and its exact git blob bytes.", + "policy_source_commit": "b4f657a0abdfdfaae199cbc7eee0c47acd8b0057", + "policy_source_files": [ + { + "blob_sha1": "ec3fab8bbd8d5e0d0a0e1c6f60e7249d97f3ef4f", + "path": "scripts/calibration/policy.py", + "size_bytes": 25486 + } + ], + "policy_source_root": "scripts/calibration/", + "policy_source_selector": "all committed *.py recursively under policy_source_root at policy_source_commit", + "policy_source_tree": "2f49574433fea23f6158f4d8544a3b1543c718d4" +} diff --git a/docs/evidence/calibration/p022-263a-training-preregistration.json b/docs/evidence/calibration/p022-263a-training-preregistration.json new file mode 100644 index 00000000..0becc1f6 --- /dev/null +++ b/docs/evidence/calibration/p022-263a-training-preregistration.json @@ -0,0 +1,170 @@ +{ + "abort_semantics": { + "durable_record": "every abort writes a structured record naming stratum, rung, run index, cell where applicable, and the condition", + "failed_invocation_or_exit_contract": "invalidates the run", + "identity_drift": "invalidates the stratum", + "missing_cell_or_incomplete_rung": "invalidates the run; a partial rung is not a smaller rung", + "no_automatic_retry": "a refusal is recorded and the collection stops; there is no retry because CI blinked", + "noise_probe_refusal": "invalidates the run that carried it", + "repeat_after_abort": "permitted only by a rule already written here, or by a new owner ruling", + "rss_mechanism_unavailable": "recorded and the affected field is null with a reason, never zero", + "timeout_or_runner_loss": "invalidates the run" + }, + "admissibility_of_observations": { + "quarantined": [ + { + "labels": [ + "POST_PREREG_LEGACY_DIAGNOSTIC", + "INADMISSIBLE_FOR_TRAINING", + "NEVER_FIT", + "NEVER_SELECT_N" + ], + "produced": "two CALIBRATION_ONLY reports of 40 timed cells per platform, uploaded as workflow artifacts", + "source": "CI run 2038, the legacy calibration pair, ubuntu-latest and windows-latest" + } + ], + "rule": "Every timing/resource observation produced outside the single owner-authorised Step-7 training collection is permanently inadmissible as fitting, N-selection, holdout, or D7 evidence, regardless of whether it predates or postdates this preregistration.", + "scope": "The labels are a record, not the mechanism. The mechanism is the rule above, which is unconditional, plus training-no-incidental-measurement, which stops a workflow regaining a path to a measurement entrypoint while step 7 is closed.", + "why_not_only_pre_step_6": "An earlier wording excluded only data recorded before this preregistration, which is narrower than the rule needs to be. It would have readmitted anything a later rerun produced, on the entirely sincere ground that it is just a diagnostic." + }, + "anchor_commit": "eedf6d3ed44ecf7bda69fa509dcd23b45960cf76", + "artifact": "p022-263a-calibration-training-preregistration", + "bindings": { + "design_constants_blob_sha1": "d03c8455cbcaf71446f88aeea0957b8e0c56c880", + "measurement_harness_digest": "562a7f7232dad2f4c79c6adfe0e1e7e25680b4b6f3444d54824bf0405e3c14b3", + "policy_implementation_digest": "c3068ed7fa880a7083866ead25fe8bf65c87889d242d8af1f7eee01582cd5cbf", + "training_scope_implementation_digest": "614bf9efe6ba2bb10e26a251c10d6c4a8fdaa99985d43ea03d76c6774447d25b", + "training_scope_root": "scripts/training/" + }, + "collection_protocol": { + "environment_rule": "the whole ladder and all runs of one stratum belong to ONE preregistered environment identity for that stratum; measuring one rung on one runner and another rung on a different runner makes N not the only variable that changed", + "observation_rule": "consecutive run pairs (r1,r2), (r2,r3), (r3,r4), (r4,r5), never a chosen five pairs after the outcome is visible", + "observations_per_cell_per_rung": 4, + "runs_per_rung_per_stratum": 5, + "runs_per_stratum": 15, + "runs_total": 30, + "warmup_discards": 2 + }, + "design_constants": { + "G": [ + 1, + 10 + ], + "M": [ + 2, + 1 + ], + "N_ladder": [ + 5, + 15, + 45 + ], + "R_runs": 5, + "q": [ + 19, + 20 + ] + }, + "exactly_one_collection": { + "identity": "the collection carries a durable identity from its first run", + "outcomes": [ + "ADMISSIBLE", + "INVALID" + ], + "rule": "exactly one training collection is run; it is not the first satisfactory one of several", + "stratum_failure": "if either stratum invalidates, the cross-platform collection yields no admissible step 8 input; the surviving stratum's numbers remain durable evidence of what happened and must never become a single-stratum fallback model" + }, + "forbidden_in_step_6": [ + "any clock", + "any new timing or resource observation", + "any fitted A_abs or R_rel", + "any selected N", + "any fitted width", + "any change to the frozen policy or the measurement harness" + ], + "future_procedure": { + "no_common_n": "an orchestration stop, not a fifth reproducibility verdict; the frozen four describe cells and run pairs and are untouched. No fallback rung, no stricter-stratum tie-break, no second margin, no second fit", + "note": "described here so it is fixed before data; step 6 produces no numeric result of it", + "rejected_alternatives": { + "averaged_widths": "lets an unstable stratum buy a stable one a wider bound", + "max_of_per_stratum_picks": "can name a rung admissible on neither stratum", + "one_stratum_as_reference": "puts the other into D7 with no measurement model of its own" + }, + "steps": [ + "per stratum, pool its cells within a rung and fit the envelope by the frozen fitter", + "per stratum, compute each rung's width and the admissible rung set by the frozen selector", + "intersect the strata's admissible sets and take the smallest ladder rung in the intersection", + "if the intersection is empty, stop with NO_COMMON_N" + ] + }, + "holdout": "not authorised by this preregistration and not described by it; the validation pair is a separate owner decision", + "identity_drift_rule": "any change to a required identity field after collection starts invalidates that stratum's training collection; two epochs are never glued into one dataset", + "order": { + "seed_derivation": "the first 16 hex digits of policy_implementation_digest, frozen at step 4 and owner-accepted before this preregistration existed, so it is not a number that could have been re-rolled until the order looked tidy", + "seed_hex": "c3068ed7fa880a70", + "stratum_order": "linux then windows, fixed", + "within_stratum_order": "ladder rungs ascending; within a rung the five runs are sequential; cell order within a run is the instrument's own fixed order and is not re-shuffled" + }, + "ratified_by": "owner", + "run_identity_required_fields": [ + "tree_sha", + "tree_dirty", + "python_reference_commit", + "python_reference_tree", + "workload_manifest_sha256", + "harness_digest", + "calibration_repetitions", + "warmup_discards", + "candidate_sha256", + "candidate_bytes", + "provenance.environment", + "provenance.timestamp_utc", + "raw samples per cell" + ], + "step_7_collection": "NOT AUTHORISED", + "stratification": { + "across_strata": "observations, medians, envelopes and widths are never pooled, averaged or summed across strata", + "cell_identity": [ + "rung", + "engine", + "workload", + "regime" + ], + "platform_is_a_cell_axis": false, + "regime_rule": "cold and warm are distinct cells of the frozen four-part identity and pool within a stratum", + "strata": [ + "linux", + "windows" + ], + "within_stratum": "every cell of U_p pools into one fit per ladder rung, by the frozen fitter unchanged" + }, + "universe": { + "applicability_rule": "the universe is exactly the cell set the frozen instrument emits for the six calibration workloads; a rung that does not apply to a workload is absent rather than N/A, and the count is asserted by a control rather than trusted", + "calibration_workloads": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ], + "decisive_workloads": "excluded, and the CALIBRATION_ONLY firewall refuses them structurally", + "engines": [ + "python", + "rust" + ], + "expected_cells_per_stratum": 40, + "pre_step6_data": "excluded from U, and so is every observation taken outside the single authorised step 7 collection whenever it was taken; see admissibility_of_observations", + "regimes": [ + "process-cold", + "warm" + ], + "rungs": [ + "core-usage", + "core-parse-refused", + "core-full-human", + "core-full-sarif", + "launcher-e2e" + ] + } +} diff --git a/docs/evidence/historical/p022-263a-calibration-run-a.linux.json b/docs/evidence/historical/p022-263a-calibration-run-a.linux.json new file mode 100644 index 00000000..169384a6 --- /dev/null +++ b/docs/evidence/historical/p022-263a-calibration-run-a.linux.json @@ -0,0 +1,3933 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "warmup_discards": 2, + "calibration_repetitions": 15, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 attestation on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "harness_digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "python_reference_commit": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118" + }, + "gate_requirements": [ + "the payload declares kind='own.net/p022/d7-freeze-attestation' and schema=1", + "the payload carries every top-level field: kind, schema, payload_sha256, c1, c2", + "the payload carries a complete C1 section: harness_digest, workload_manifest_sha256, python_reference_commit", + "the payload carries a complete C2 section (presence only; the gate never reads a single one of these values): repetitions_ladder, comparison_estimator, thresholds", + "payload_sha256 equals a hash recomputed over the payload's own canonical body", + "C1 matches the identities this process observes", + "a ratification exists at p022-263a-d7-ratification.json, declares kind='own.net/p022/d7-freeze-ratification', and carries: kind, schema, owner, payload_path, payload_commit_sha, ratified_payload_sha256, signature", + "ratified_payload_sha256 equals that same recomputed body hash", + "payload_path is exactly the repository-relative path this instrument reads its payload from — a ratification may not choose which file it is about", + "payload_commit_sha names a commit that exists, and the payload's working-tree bytes are the blob at that path, resolved from the git TREE ROOT, in that commit", + "the ratification is itself committed and unmodified in the working tree", + "signature is exactly \"none\", recorded as unsigned; signed ratification is not part of this version's accepted contract" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T08:09:26Z", + "measurements_taken": 600 + } + }, + "provenance": { + "tree_sha": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118", + "tree_dirty": false, + "python_reference_commit": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.80GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T08:17:08Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 22769782, + "iqr_ns": 1320596.5, + "min_ns": 21401484, + "relative_iqr": 0.05799776651353096, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 22631676, + "iqr_ns": 729101.0, + "min_ns": 21472341, + "relative_iqr": 0.03221595254368258, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2741275, + "min_ns": 2532933, + "mad_ns": 115263, + "iqr_ns": 303211.0, + "q1_ns": 2626012.0, + "q3_ns": 2929223.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25038848, + "min_bytes": 25038848, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25038848.0, + "q3_bytes": 25038848.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3666957, + 2741275, + 2596025, + 2929223, + 2626012, + 2674199, + 2798826, + 2605927, + 3251104, + 2532933, + 3064766, + 2762567, + 2750342, + 2704461, + 2700247 + ], + "raw_peak_rss_bytes": [ + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848, + 25038848 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3303352448, + "min_ns": 3075652508, + "mad_ns": 80359945, + "iqr_ns": 184093950.0, + "q1_ns": 3195987424.0, + "q3_ns": 3380081374.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178728960, + "min_bytes": 178176000, + "mad_bytes": 225280, + "iqr_bytes": 495616.0, + "q1_bytes": 178458624.0, + "q3_bytes": 178954240.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3380081374, + 3291252831, + 3303352448, + 3558037969, + 3383712393, + 3327237271, + 3302744302, + 3222858119, + 3075652508, + 3076622603, + 3158890287, + 3373167907, + 3543285191, + 3195987424, + 3308968098 + ], + "raw_peak_rss_bytes": [ + 178700288, + 178728960, + 178225152, + 178266112, + 179187712, + 178970624, + 178802688, + 178585600, + 178827264, + 178458624, + 178176000, + 178954240, + 179019776, + 178511872, + 178880512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 82631375, + "min_ns": 78314363, + "mad_ns": 2020584, + "iqr_ns": 4525671.0, + "q1_ns": 80610791.0, + "q3_ns": 85136462.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25178112, + "min_bytes": 25178112, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25178112.0, + "q3_bytes": 25178112.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 81116882, + 81034577, + 78314363, + 80610791, + 80120672, + 85564266, + 86562992, + 83093485, + 82631375, + 83413104, + 80507264, + 82598402, + 84053236, + 85136462, + 90732090 + ], + "raw_peak_rss_bytes": [ + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 110935965, + "min_ns": 106283497, + "mad_ns": 2964860, + "iqr_ns": 6025291.0, + "q1_ns": 107971105.0, + "q3_ns": 113996396.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25178112, + "min_bytes": 25178112, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25178112.0, + "q3_bytes": 25178112.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 109509713, + 115132741, + 110823615, + 106283497, + 107871935, + 106912228, + 107971105, + 108504489, + 113587931, + 110935965, + 114193750, + 113288477, + 113996396, + 112730234, + 114328454 + ], + "raw_peak_rss_bytes": [ + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112, + 25178112 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3079321875, + "min_ns": 2970143396, + "mad_ns": 35422938, + "iqr_ns": 137676791.0, + "q1_ns": 3043898937.0, + "q3_ns": 3181575728.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178782208, + "min_bytes": 178356224, + "mad_bytes": 241664, + "iqr_bytes": 495616.0, + "q1_bytes": 178540544.0, + "q3_bytes": 179036160.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3062985173, + 2970143396, + 3042065570, + 3040768423, + 3043898937, + 3079321875, + 3198625071, + 3251278552, + 3065709926, + 3112034539, + 3111350447, + 3189830080, + 3181575728, + 3101962241, + 3063341372 + ], + "raw_peak_rss_bytes": [ + 178774016, + 179179520, + 179023872, + 178765824, + 178782208, + 179081216, + 178454528, + 178540544, + 178700288, + 178356224, + 178937856, + 178831360, + 179089408, + 178380800, + 179036160 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 111484138, + "min_ns": 103853344, + "mad_ns": 3121208, + "iqr_ns": 7463521.0, + "q1_ns": 106479668.0, + "q3_ns": 113943189.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25186304, + "min_bytes": 25186304, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25186304.0, + "q3_bytes": 25186304.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 106943177, + 106479668, + 109259039, + 114605346, + 111484138, + 104728189, + 103853344, + 124505678, + 113692424, + 105814436, + 113943189, + 110671741, + 111772964, + 117075286, + 113841534 + ], + "raw_peak_rss_bytes": [ + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304, + 25186304 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 117068268, + "min_ns": 110190430, + "mad_ns": 2582213, + "iqr_ns": 4937622.0, + "q1_ns": 115143930.0, + "q3_ns": 120081552.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25190400, + "min_bytes": 25190400, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25190400.0, + "q3_bytes": 25190400.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 120042284, + 115143930, + 110190430, + 116549207, + 120081552, + 119650481, + 117891114, + 112401298, + 153937939, + 116714296, + 137353110, + 117068268, + 114746199, + 133448965, + 116134269 + ], + "raw_peak_rss_bytes": [ + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400, + 25190400 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 114464163, + "min_ns": 108766293, + "mad_ns": 3098324, + "iqr_ns": 7192753.0, + "q1_ns": 112029523.0, + "q3_ns": 119222276.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25194496, + "min_bytes": 25194496, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25194496.0, + "q3_bytes": 25194496.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 111365839, + 113960433, + 119860343, + 114464163, + 110462630, + 112029523, + 114679035, + 112326819, + 150256344, + 108766293, + 118874543, + 113209930, + 119776011, + 119222276, + 117334779 + ], + "raw_peak_rss_bytes": [ + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496, + 25194496 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3267418652, + "min_ns": 3088444579, + "mad_ns": 76989300, + "iqr_ns": 184485921.0, + "q1_ns": 3159922031.0, + "q3_ns": 3344407952.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178724864, + "min_bytes": 177508352, + "mad_bytes": 159744, + "iqr_bytes": 393216.0, + "q1_bytes": 178475008.0, + "q3_bytes": 178868224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3331126286, + 3319187122, + 3193448571, + 3235610028, + 3105407304, + 3126581586, + 3356284133, + 3317611415, + 3363776006, + 3344407952, + 3462355341, + 3267418652, + 3236905597, + 3159922031, + 3088444579 + ], + "raw_peak_rss_bytes": [ + 179621888, + 178884608, + 178343936, + 177508352, + 178753536, + 178757632, + 178466816, + 178679808, + 178712576, + 178868224, + 178798592, + 178495488, + 179322880, + 178475008, + 178724864 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 102901961, + "min_ns": 99154530, + "mad_ns": 3211124, + "iqr_ns": 7509182.0, + "q1_ns": 99876438.0, + "q3_ns": 107385620.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25202688, + "min_bytes": 25202688, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25202688.0, + "q3_bytes": 25202688.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 99690837, + 99876438, + 101158252, + 102125461, + 104363672, + 99154530, + 107852314, + 107385620, + 108260413, + 102901961, + 99512077, + 105062983, + 116351369, + 107368145, + 99916842 + ], + "raw_peak_rss_bytes": [ + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688, + 25202688 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3103734699, + "min_ns": 2962363478, + "mad_ns": 49699513, + "iqr_ns": 105123212.0, + "q1_ns": 3081474269.0, + "q3_ns": 3186597481.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178757632, + "min_bytes": 178171904, + "mad_bytes": 143360, + "iqr_bytes": 311296.0, + "q1_bytes": 178675712.0, + "q3_bytes": 178987008.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3273696610, + 3103734699, + 3166135310, + 3099018000, + 3166496093, + 3098311546, + 3062574016, + 3094808730, + 3186597481, + 3081474269, + 4408067899, + 3210769462, + 3130952716, + 3054035186, + 2962363478 + ], + "raw_peak_rss_bytes": [ + 178892800, + 178757632, + 178675712, + 179183616, + 178614272, + 178798592, + 178987008, + 178712576, + 178593792, + 178728960, + 178958336, + 179163136, + 178995200, + 178696192, + 178171904 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2237125, + "min_ns": 2135256, + "mad_ns": 45279, + "iqr_ns": 84879.0, + "q1_ns": 2197564.0, + "q3_ns": 2282443.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25206784, + "min_bytes": 25206784, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25206784.0, + "q3_bytes": 25206784.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2256109, + 2220012, + 2784265, + 2237125, + 2197564, + 2274507, + 2135256, + 2211241, + 2384033, + 2159599, + 2282404, + 2203100, + 2282443, + 2300663, + 2173465 + ], + "raw_peak_rss_bytes": [ + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784, + 25206784 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1755845, + "min_ns": 1644626, + "mad_ns": 41894, + "iqr_ns": 83866.0, + "q1_ns": 1713873.0, + "q3_ns": 1797739.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25210880, + "min_bytes": 25210880, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25210880.0, + "q3_bytes": 25210880.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1690424, + 1790792, + 1756027, + 1713873, + 1913492, + 1679511, + 1738802, + 1644626, + 1838222, + 1755845, + 1892610, + 1714358, + 1760409, + 1722318, + 1797739 + ], + "raw_peak_rss_bytes": [ + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 112501579, + "min_ns": 106231504, + "mad_ns": 4162289, + "iqr_ns": 7977061.0, + "q1_ns": 108071226.0, + "q3_ns": 116048287.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25210880, + "min_bytes": 25210880, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25210880.0, + "q3_bytes": 25210880.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 119581915, + 127511123, + 113979192, + 108071226, + 111397071, + 112501579, + 107428577, + 115682063, + 116048287, + 108850957, + 139948802, + 115703032, + 106231504, + 106639139, + 108339290 + ], + "raw_peak_rss_bytes": [ + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 5569299, + "min_ns": 5338293, + "mad_ns": 113522, + "iqr_ns": 254536.0, + "q1_ns": 5428285.0, + "q3_ns": 5682821.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25210880, + "min_bytes": 25210880, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25210880.0, + "q3_bytes": 25210880.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5682821, + 5702337, + 5428285, + 5586310, + 5395822, + 5541809, + 5461265, + 6178945, + 5650001, + 5569299, + 5347727, + 5338293, + 5603807, + 5724882, + 5473301 + ], + "raw_peak_rss_bytes": [ + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1700032, + "min_ns": 1621453, + "mad_ns": 54820, + "iqr_ns": 112748.0, + "q1_ns": 1642104.0, + "q3_ns": 1754852.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25210880, + "min_bytes": 25210880, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25210880.0, + "q3_bytes": 25210880.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1806506, + 1624339, + 1700032, + 1743520, + 1642104, + 1654181, + 1679344, + 1848118, + 1638651, + 1688906, + 1716731, + 1621453, + 1754852, + 1700718, + 2363662 + ], + "raw_peak_rss_bytes": [ + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880, + 25210880 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 6251342, + "min_ns": 5546006, + "mad_ns": 442430, + "iqr_ns": 1030534.0, + "q1_ns": 5903431.0, + "q3_ns": 6933965.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25219072, + "min_bytes": 25219072, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25219072.0, + "q3_bytes": 25219072.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 7586148, + 6591829, + 6982921, + 6114796, + 5726495, + 6933965, + 6211200, + 6391098, + 5903431, + 5546006, + 5798936, + 6067526, + 6693772, + 7374297, + 6251342 + ], + "raw_peak_rss_bytes": [ + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072, + 25219072 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2260936, + "min_ns": 2120974, + "mad_ns": 68094, + "iqr_ns": 177134.0, + "q1_ns": 2203419.0, + "q3_ns": 2380553.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2260936, + 2478731, + 2371696, + 2406681, + 2319158, + 2232763, + 2232180, + 2380553, + 2278123, + 2203419, + 2192842, + 2162986, + 2433214, + 2230969, + 2120974 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 98478189, + "min_ns": 95247523, + "mad_ns": 1930393, + "iqr_ns": 5227798.0, + "q1_ns": 97030479.0, + "q3_ns": 102258277.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 97731906, + 99150741, + 100527092, + 98478189, + 98179208, + 96547796, + 95247523, + 102258277, + 102764188, + 116244111, + 108845691, + 97043035, + 96417490, + 97030479, + 99042930 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2143643, + "min_ns": 2061535, + "mad_ns": 49702, + "iqr_ns": 108457.0, + "q1_ns": 2097581.0, + "q3_ns": 2206038.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2193345, + 2216016, + 2076368, + 2237042, + 2142997, + 2206038, + 2078079, + 2181216, + 2119191, + 2250004, + 2097581, + 2109721, + 2151703, + 2061535, + 2143643 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1640958, + "min_ns": 1586121, + "mad_ns": 34344, + "iqr_ns": 83085.0, + "q1_ns": 1606614.0, + "q3_ns": 1689699.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1630100, + 1689699, + 1698255, + 1640958, + 1651810, + 1624635, + 1595949, + 1606614, + 1662602, + 1714734, + 1586121, + 1646872, + 1601238, + 1633300, + 1694582 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3097528538, + "min_ns": 2993226688, + "mad_ns": 39417106, + "iqr_ns": 81683911.0, + "q1_ns": 3034470430.0, + "q3_ns": 3116154341.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178819072, + "min_bytes": 175022080, + "mad_bytes": 139264, + "iqr_bytes": 389120.0, + "q1_bytes": 178561024.0, + "q3_bytes": 178950144.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3034470430, + 3102111604, + 3116154341, + 3114842247, + 3161453375, + 3083457572, + 3043062761, + 3058111432, + 3099517279, + 2993226688, + 3123235936, + 3033927127, + 3157881802, + 3097528538, + 3033008515 + ], + "raw_peak_rss_bytes": [ + 178888704, + 178561024, + 178769920, + 178663424, + 178491392, + 178917376, + 178958336, + 178819072, + 178950144, + 178880512, + 178704384, + 178991104, + 179023872, + 178475008, + 175022080 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1879742, + "min_ns": 1792404, + "mad_ns": 40313, + "iqr_ns": 101456.0, + "q1_ns": 1815076.0, + "q3_ns": 1916532.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1967287, + 1912102, + 1891058, + 1792404, + 1879742, + 1846882, + 1809725, + 1852726, + 1916532, + 1894391, + 1815076, + 1951750, + 1796073, + 1978143, + 1839429 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 110473801, + "min_ns": 107043172, + "mad_ns": 1957040, + "iqr_ns": 3545946.0, + "q1_ns": 108162410.0, + "q3_ns": 111708356.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 109163212, + 108136786, + 109418750, + 112680879, + 110476721, + 108162410, + 107529100, + 115645478, + 107043172, + 111592096, + 111708356, + 108516761, + 112433379, + 110566842, + 110473801 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 97663226, + "min_ns": 94891282, + "mad_ns": 1201178, + "iqr_ns": 2449312.0, + "q1_ns": 96415092.0, + "q3_ns": 98864404.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 97663226, + 97415792, + 100838016, + 98726099, + 94891282, + 96813383, + 99957162, + 97435210, + 95558911, + 97669781, + 95340656, + 100101646, + 96415092, + 98864404, + 98542133 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 110391564, + "min_ns": 106048235, + "mad_ns": 1442657, + "iqr_ns": 4402987.0, + "q1_ns": 108948907.0, + "q3_ns": 113351894.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 119377127, + 111539829, + 113844473, + 113351894, + 110391564, + 109739910, + 110392551, + 106048235, + 106695174, + 111715722, + 108948907, + 113792209, + 109153990, + 108531877, + 110183871 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 102154525, + "min_ns": 98402062, + "mad_ns": 2592837, + "iqr_ns": 7891654.0, + "q1_ns": 99561688.0, + "q3_ns": 107453342.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 102154525, + 98402062, + 100903393, + 117071002, + 103206167, + 108293450, + 130731814, + 99561688, + 100318847, + 101675765, + 104281332, + 98868013, + 102580922, + 98744316, + 107453342 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3258830118, + "min_ns": 3072248724, + "mad_ns": 61369511, + "iqr_ns": 137420272.0, + "q1_ns": 3182779357.0, + "q3_ns": 3320199629.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178597888, + "min_bytes": 178094080, + "mad_bytes": 118784, + "iqr_bytes": 274432.0, + "q1_bytes": 178479104.0, + "q3_bytes": 178753536.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3072248724, + 3208095318, + 3290588225, + 3258830118, + 3343831317, + 3216916257, + 3182779357, + 3273601354, + 3242774516, + 3304405368, + 3369816187, + 3322929791, + 3320199629, + 3144778497, + 3174204883 + ], + "raw_peak_rss_bytes": [ + 178626560, + 178294784, + 178094080, + 179138560, + 178589696, + 178757632, + 178343936, + 178597888, + 178528256, + 178753536, + 178585600, + 178597888, + 178798592, + 178614272, + 178479104 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3015065698, + "min_ns": 2899711723, + "mad_ns": 81853839, + "iqr_ns": 178617693.0, + "q1_ns": 2956246263.0, + "q3_ns": 3134863956.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178958336, + "min_bytes": 178290688, + "mad_bytes": 196608, + "iqr_bytes": 413696.0, + "q1_bytes": 178630656.0, + "q3_bytes": 179044352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3139983417, + 2925316985, + 2899711723, + 2943475591, + 3057672020, + 2976300254, + 2956246263, + 3137149995, + 3134863956, + 3217318152, + 3006125875, + 3000195042, + 3115589919, + 3096919537, + 3015065698 + ], + "raw_peak_rss_bytes": [ + 179019776, + 178290688, + 178638848, + 179052544, + 178999296, + 178761728, + 178737152, + 178524160, + 178630656, + 179261440, + 179044352, + 178958336, + 178569216, + 179040256, + 179154944 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 6087932, + "min_ns": 5458152, + "mad_ns": 594215, + "iqr_ns": 2144247.0, + "q1_ns": 5827574.0, + "q3_ns": 7971821.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5827574, + 7576512, + 5977204, + 7971821, + 5757252, + 5458152, + 8850287, + 6087932, + 5652798, + 5880625, + 5959409, + 8965971, + 6682147, + 8448596, + 7312244 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 6640535, + "min_ns": 5900086, + "mad_ns": 462574, + "iqr_ns": 2171207.0, + "q1_ns": 6177961.0, + "q3_ns": 8349168.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6883063, + 6673290, + 6720204, + 6177961, + 6248600, + 6082447, + 6175366, + 5900086, + 8708520, + 6640535, + 8349168, + 8655460, + 6629370, + 8824064, + 6342942 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 105311615, + "min_ns": 97648082, + "mad_ns": 2375992, + "iqr_ns": 6905599.0, + "q1_ns": 103980859.0, + "q3_ns": 110886458.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 104319002, + 97648082, + 105311615, + 105104029, + 106799036, + 112787520, + 111406592, + 98212450, + 103980859, + 102935623, + 107069929, + 104366191, + 108967446, + 110886458, + 123219120 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 84788661, + "min_ns": 78711543, + "mad_ns": 3719517, + "iqr_ns": 8241517.0, + "q1_ns": 81253590.0, + "q3_ns": 89495107.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 78711543, + 84970976, + 82365305, + 101885447, + 80871327, + 79116153, + 84788661, + 87376456, + 89495107, + 88508178, + 99408078, + 83217737, + 84134249, + 81253590, + 104618382 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3022874012, + "min_ns": 2911019865, + "mad_ns": 62019301, + "iqr_ns": 147590385.0, + "q1_ns": 2962405583.0, + "q3_ns": 3109995968.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178589696, + "min_bytes": 178040832, + "mad_bytes": 188416, + "iqr_bytes": 454656.0, + "q1_bytes": 178401280.0, + "q3_bytes": 178855936.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3224573186, + 3110351750, + 3081996176, + 2921794022, + 2911019865, + 3022874012, + 3097745170, + 3109995968, + 3144650723, + 2985962035, + 3021049229, + 2960854711, + 2962405583, + 3005207269, + 3031782191 + ], + "raw_peak_rss_bytes": [ + 178761728, + 178274304, + 178589696, + 178507776, + 178716672, + 178040832, + 179126272, + 178401280, + 178855936, + 178991104, + 179130368, + 178651136, + 178503680, + 178536448, + 178180096 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1964101, + "min_ns": 1824606, + "mad_ns": 60804, + "iqr_ns": 127669.0, + "q1_ns": 1880761.0, + "q3_ns": 2008430.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2207304, + 2008430, + 2004134, + 1881861, + 1981999, + 1903772, + 2281702, + 1935165, + 2001721, + 1824606, + 2024905, + 1832737, + 1873783, + 1880761, + 1964101 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1905410, + "min_ns": 1801211, + "mad_ns": 61000, + "iqr_ns": 119795.0, + "q1_ns": 1864680.0, + "q3_ns": 1984475.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1984475, + 1966410, + 1864680, + 2082506, + 1873549, + 1905410, + 1963716, + 1873024, + 1807590, + 1842466, + 1873974, + 2017313, + 2005326, + 1801211, + 1944682 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1955477, + "min_ns": 1788516, + "mad_ns": 101385, + "iqr_ns": 161599.0, + "q1_ns": 1849558.0, + "q3_ns": 2011157.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2207788, + 1969137, + 2262263, + 1854092, + 1849558, + 1970235, + 2115770, + 1814999, + 2011157, + 1971432, + 1872369, + 1955477, + 1788516, + 1818099, + 1875832 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 100273185, + "min_ns": 97999263, + "mad_ns": 1490624, + "iqr_ns": 3111670.0, + "q1_ns": 98782561.0, + "q3_ns": 101894231.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 100273185, + 97999263, + 101894231, + 100503432, + 98500987, + 99902903, + 102690443, + 100092344, + 98782561, + 122855078, + 99236900, + 101281778, + 106740353, + 98423897, + 100355333 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 114605679, + "min_ns": 109448922, + "mad_ns": 1782495, + "iqr_ns": 4351891.0, + "q1_ns": 112823184.0, + "q3_ns": 117175075.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 109448922, + 113708339, + 109685375, + 113220108, + 112432680, + 112823184, + 115806381, + 117175075, + 114957135, + 117940573, + 118601064, + 114605679, + 113972437, + 115161745, + 130908317 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1888329, + "min_ns": 1723410, + "mad_ns": 82128, + "iqr_ns": 158423.0, + "q1_ns": 1848578.0, + "q3_ns": 2007001.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25223168, + "min_bytes": 25223168, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25223168.0, + "q3_bytes": 25223168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2044962, + 1888329, + 2108155, + 1848578, + 1875459, + 1970824, + 1869513, + 1889526, + 2007001, + 1887347, + 2039112, + 1952872, + 1806201, + 1723410, + 1729174 + ], + "raw_peak_rss_bytes": [ + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168, + 25223168 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "admissibility": { + "outcomes_reproduced": null, + "timings_reproduced": null, + "environment_valid": true, + "admissible": false, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/historical/p022-263a-sizing-n15.linux.json b/docs/evidence/historical/p022-263a-sizing-n15.linux.json new file mode 100644 index 00000000..a8c96d39 --- /dev/null +++ b/docs/evidence/historical/p022-263a-sizing-n15.linux.json @@ -0,0 +1,3972 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "warmup_discards": 2, + "calibration_repetitions": 15, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 attestation on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "harness_digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "python_reference_commit": "742dad7483f9b3f998dc131f9233781bd4d4960d" + }, + "gate_requirements": [ + "the payload declares kind='own.net/p022/d7-freeze-attestation' and schema=1", + "the payload carries every top-level field: kind, schema, payload_sha256, c1, c2", + "the payload carries a complete C1 section: harness_digest, workload_manifest_sha256, python_reference_commit", + "the payload carries a complete C2 section (presence only; the gate never reads a single one of these values): repetitions_ladder, comparison_estimator, thresholds", + "payload_sha256 equals a hash recomputed over the payload's own canonical body", + "C1 matches the identities this process observes", + "a ratification exists at p022-263a-d7-ratification.json, declares kind='own.net/p022/d7-freeze-ratification', and carries: kind, schema, owner, payload_path, payload_commit_sha, ratified_payload_sha256, signature", + "ratified_payload_sha256 equals that same recomputed body hash", + "payload_path is exactly the repository-relative path this instrument reads its payload from — a ratification may not choose which file it is about", + "payload_commit_sha names a commit that exists, and the payload's working-tree bytes are the blob at that path, resolved from the git TREE ROOT, in that commit", + "the ratification is itself committed and unmodified in the working tree", + "signature is exactly \"none\", recorded as unsigned; signed ratification is not part of this version's accepted contract" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T08:20:53Z", + "measurements_taken": 600 + } + }, + "provenance": { + "tree_sha": "742dad7483f9b3f998dc131f9233781bd4d4960d", + "tree_dirty": false, + "python_reference_commit": "742dad7483f9b3f998dc131f9233781bd4d4960d", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.80GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T08:28:30Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 23184448, + "iqr_ns": 1483863.5, + "min_ns": 22517903, + "relative_iqr": 0.06400253739058183, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 22614792, + "iqr_ns": 830467.5, + "min_ns": 22024396, + "relative_iqr": 0.036722314315338386, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2435446, + "min_ns": 2178467, + "mad_ns": 254713, + "iqr_ns": 700170.0, + "q1_ns": 2287464.0, + "q3_ns": 2987634.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25088000, + "min_bytes": 25088000, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25088000.0, + "q3_bytes": 25088000.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3579131, + 2371786, + 2933087, + 2435446, + 2287464, + 2997139, + 2462917, + 2987634, + 2178467, + 2327931, + 2975481, + 2332060, + 3052021, + 2180733, + 2231517 + ], + "raw_peak_rss_bytes": [ + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000, + 25088000 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3174029915, + "min_ns": 3059543092, + "mad_ns": 83537753, + "iqr_ns": 174635734.0, + "q1_ns": 3082931934.0, + "q3_ns": 3257567668.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178536448, + "min_bytes": 178208768, + "mad_bytes": 139264, + "iqr_bytes": 339968.0, + "q1_bytes": 178446336.0, + "q3_bytes": 178786304.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3082931934, + 3059543092, + 3126871887, + 3240739896, + 3396456402, + 3255703345, + 3080976238, + 3174029915, + 3356484412, + 3409579882, + 3257567668, + 3111867565, + 3063578847, + 3115139669, + 3226431778 + ], + "raw_peak_rss_bytes": [ + 178454528, + 178761728, + 178450432, + 178851840, + 178446336, + 178208768, + 179130368, + 178786304, + 178659328, + 178855936, + 178515968, + 178397184, + 178536448, + 178614272, + 178245632 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 77587439, + "min_ns": 73321858, + "mad_ns": 2177139, + "iqr_ns": 5088453.0, + "q1_ns": 75410300.0, + "q3_ns": 80498753.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25112576, + "min_bytes": 25112576, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25112576.0, + "q3_bytes": 25112576.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 77391037, + 82452132, + 78041019, + 79588587, + 77587439, + 81211596, + 77927813, + 75756280, + 75410300, + 73321858, + 75216810, + 76504601, + 80718746, + 74814079, + 80498753 + ], + "raw_peak_rss_bytes": [ + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576, + 25112576 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 105096450, + "min_ns": 100509225, + "mad_ns": 2816914, + "iqr_ns": 9727939.0, + "q1_ns": 102279536.0, + "q3_ns": 112007475.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25120768, + "min_bytes": 25120768, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25120768.0, + "q3_bytes": 25120768.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 105096450, + 107057226, + 112007475, + 105313563, + 102279536, + 104469288, + 100509225, + 101587189, + 104594015, + 106679311, + 112523817, + 125867113, + 113089390, + 105022479, + 100756293 + ], + "raw_peak_rss_bytes": [ + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768, + 25120768 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3025959091, + "min_ns": 2868358868, + "mad_ns": 86404205, + "iqr_ns": 199972326.0, + "q1_ns": 2939554886.0, + "q3_ns": 3139527212.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178929664, + "min_bytes": 178147328, + "mad_bytes": 241664, + "iqr_bytes": 524288.0, + "q1_bytes": 178585600.0, + "q3_bytes": 179109888.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3079607138, + 3139527212, + 3026684308, + 3067379458, + 3025959091, + 3024481802, + 2965893698, + 2906704365, + 2994813222, + 2939554886, + 2868358868, + 2914295222, + 3179930120, + 3212895723, + 3141603198 + ], + "raw_peak_rss_bytes": [ + 179109888, + 178688000, + 178982912, + 178851840, + 178929664, + 178937856, + 179355648, + 178708480, + 179281920, + 179277824, + 179060736, + 178147328, + 178585600, + 178339840, + 178462720 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 103770501, + "min_ns": 100030960, + "mad_ns": 2214269, + "iqr_ns": 5577474.0, + "q1_ns": 101556232.0, + "q3_ns": 107133706.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25128960, + "min_bytes": 25128960, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25128960.0, + "q3_bytes": 25128960.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 107885620, + 111314095, + 107208060, + 105223864, + 100030960, + 103689584, + 101556232, + 100983536, + 102061764, + 105195772, + 104683227, + 107133706, + 103770501, + 103713098, + 100097573 + ], + "raw_peak_rss_bytes": [ + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 101749041, + "min_ns": 98056507, + "mad_ns": 3124610, + "iqr_ns": 6285096.0, + "q1_ns": 98588555.0, + "q3_ns": 104873651.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25128960, + "min_bytes": 25128960, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25128960.0, + "q3_bytes": 25128960.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 107045497, + 107657677, + 110296708, + 98056507, + 100597704, + 101773986, + 98393787, + 98216779, + 99739489, + 101877725, + 101749041, + 98588555, + 100546911, + 102472509, + 104873651 + ], + "raw_peak_rss_bytes": [ + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960, + 25128960 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 99946024, + "min_ns": 97164238, + "mad_ns": 1397821, + "iqr_ns": 3103387.0, + "q1_ns": 98240458.0, + "q3_ns": 101343845.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25133056, + "min_bytes": 25133056, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25133056.0, + "q3_bytes": 25133056.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 97676891, + 99946024, + 100511830, + 98943401, + 100257860, + 101343845, + 105415200, + 98805839, + 98141809, + 98240458, + 97164238, + 100896721, + 101672297, + 99716761, + 102904043 + ], + "raw_peak_rss_bytes": [ + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3187324517, + "min_ns": 3053553156, + "mad_ns": 55163548, + "iqr_ns": 120810053.0, + "q1_ns": 3121678012.0, + "q3_ns": 3242488065.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178728960, + "min_bytes": 178290688, + "mad_bytes": 258048, + "iqr_bytes": 528384.0, + "q1_bytes": 178470912.0, + "q3_bytes": 178999296.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3162182206, + 3113232771, + 3109902641, + 3283277959, + 3319102840, + 3242488065, + 3367434760, + 3187331586, + 3053553156, + 3144767707, + 3181493337, + 3187324517, + 3233340055, + 3121678012, + 3198741284 + ], + "raw_peak_rss_bytes": [ + 178999296, + 179257344, + 178651136, + 178872320, + 179048448, + 178683904, + 178401280, + 178667520, + 178728960, + 178290688, + 178294784, + 178470912, + 179073024, + 178823168, + 178823168 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 103209355, + "min_ns": 97920995, + "mad_ns": 4747014, + "iqr_ns": 8397543.0, + "q1_ns": 100338982.0, + "q3_ns": 108736525.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25133056, + "min_bytes": 25133056, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25133056.0, + "q3_bytes": 25133056.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 108304067, + 102562211, + 100338982, + 109798412, + 97920995, + 107956369, + 111597290, + 100391831, + 97936384, + 99304843, + 101156756, + 104912275, + 103209355, + 108736525, + 144487606 + ], + "raw_peak_rss_bytes": [ + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056, + 25133056 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3126635429, + "min_ns": 2993580146, + "mad_ns": 79488304, + "iqr_ns": 259215184.0, + "q1_ns": 3047147125.0, + "q3_ns": 3306362309.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178753536, + "min_bytes": 178044928, + "mad_bytes": 114688, + "iqr_bytes": 348160.0, + "q1_bytes": 178507776.0, + "q3_bytes": 178855936.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3086522764, + 3085916690, + 3189979196, + 3047147125, + 2993580146, + 3007909695, + 3139337318, + 3126635429, + 3016366921, + 3061783301, + 3140841088, + 3430986075, + 3366904475, + 3306362309, + 3326428223 + ], + "raw_peak_rss_bytes": [ + 178475008, + 178659328, + 178855936, + 178638848, + 179113984, + 178753536, + 178827264, + 178720768, + 178044928, + 179445760, + 178429952, + 178831360, + 178831360, + 178982912, + 178507776 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3122115, + "min_ns": 2174172, + "mad_ns": 375564, + "iqr_ns": 1222631.0, + "q1_ns": 2267280.0, + "q3_ns": 3489911.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3690533, + 2777199, + 3308126, + 2267280, + 3082694, + 2174172, + 3592061, + 2237726, + 3195012, + 3489911, + 2231060, + 3122115, + 2289654, + 3199341, + 3497679 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2197420, + "min_ns": 1790659, + "mad_ns": 258007, + "iqr_ns": 641180.0, + "q1_ns": 2012820.0, + "q3_ns": 2654000.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2624046, + 2654000, + 1944234, + 2383270, + 1790659, + 2708797, + 2082802, + 2112559, + 2584271, + 2036282, + 2884091, + 2012820, + 1939413, + 2882250, + 2197420 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 121298881, + "min_ns": 113476199, + "mad_ns": 5354062, + "iqr_ns": 9143304.0, + "q1_ns": 117933883.0, + "q3_ns": 127077187.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 121654590, + 114775282, + 115813449, + 113476199, + 130471961, + 121588938, + 121298881, + 117933883, + 119967710, + 119476085, + 120378418, + 127077187, + 130408871, + 159878694, + 126652943 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 6825995, + "min_ns": 6176010, + "mad_ns": 289105, + "iqr_ns": 548448.0, + "q1_ns": 6571738.0, + "q3_ns": 7120186.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6651895, + 6536890, + 6176010, + 6393689, + 6825995, + 8376005, + 6800814, + 7120186, + 8049526, + 6835492, + 6696871, + 7927756, + 6852972, + 7118499, + 6571738 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1902073, + "min_ns": 1803421, + "mad_ns": 86167, + "iqr_ns": 250659.0, + "q1_ns": 1823504.0, + "q3_ns": 2074163.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1885377, + 1902073, + 2087641, + 2014339, + 1815906, + 2254289, + 2231037, + 1963593, + 1823504, + 1859078, + 1809122, + 1960969, + 2074163, + 1803421, + 1896051 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 7425882, + "min_ns": 5902672, + "mad_ns": 926693, + "iqr_ns": 2019909.0, + "q1_ns": 6584989.0, + "q3_ns": 8604898.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5902672, + 6499189, + 8604898, + 6584989, + 6785885, + 8525316, + 7005870, + 8940391, + 7005940, + 7527073, + 8849944, + 7819480, + 10452666, + 7425882, + 6429004 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3217459, + "min_ns": 2451641, + "mad_ns": 208002, + "iqr_ns": 690035.0, + "q1_ns": 2623307.0, + "q3_ns": 3313342.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3464964, + 3371905, + 2602573, + 3278185, + 2451641, + 3454249, + 3083334, + 3313342, + 3009457, + 2623307, + 3217459, + 3287337, + 2537034, + 2744604, + 3254622 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 106921988, + "min_ns": 100837882, + "mad_ns": 2839357, + "iqr_ns": 6338551.0, + "q1_ns": 104082631.0, + "q3_ns": 110421182.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25141248, + "min_bytes": 25141248, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25141248.0, + "q3_bytes": 25141248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 107089192, + 110421182, + 111510107, + 134567846, + 109707913, + 146442758, + 104082631, + 108025620, + 105458761, + 106921988, + 100837882, + 102896071, + 105615056, + 102078046, + 106248526 + ], + "raw_peak_rss_bytes": [ + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248, + 25141248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2599099, + "min_ns": 2507387, + "mad_ns": 59971, + "iqr_ns": 248913.0, + "q1_ns": 2567566.0, + "q3_ns": 2816479.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25161728, + "min_bytes": 25161728, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25161728.0, + "q3_bytes": 25161728.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2983092, + 2599099, + 2933148, + 2816479, + 2623292, + 2673662, + 2660343, + 2551356, + 2568171, + 2592886, + 2507387, + 2539128, + 2569908, + 2881062, + 2567566 + ], + "raw_peak_rss_bytes": [ + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2488252, + "min_ns": 1887966, + "mad_ns": 427467, + "iqr_ns": 862444.0, + "q1_ns": 2060785.0, + "q3_ns": 2923229.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25161728, + "min_bytes": 25161728, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25161728.0, + "q3_bytes": 25161728.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2098284, + 2266061, + 2043119, + 2066850, + 2060785, + 43657165, + 3074556, + 2801181, + 2750765, + 2923229, + 2676894, + 2003421, + 3690783, + 2488252, + 1887966 + ], + "raw_peak_rss_bytes": [ + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728, + 25161728 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3045615754, + "min_ns": 2962116664, + "mad_ns": 66518625, + "iqr_ns": 156234708.0, + "q1_ns": 2987354245.0, + "q3_ns": 3143588953.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178667520, + "min_bytes": 178044928, + "mad_bytes": 299008, + "iqr_bytes": 598016.0, + "q1_bytes": 178368512.0, + "q3_bytes": 178966528.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3185580769, + 3253164308, + 3045615754, + 2968351745, + 3033028668, + 2988178427, + 3226050114, + 3143588953, + 2987354245, + 3003624480, + 3135164055, + 3093277995, + 2979097129, + 3059998258, + 2962116664 + ], + "raw_peak_rss_bytes": [ + 178044928, + 179101696, + 178966528, + 178196480, + 178708480, + 179154944, + 178278400, + 178368512, + 178819072, + 178987008, + 178954240, + 178450432, + 178561024, + 178667520, + 178511872 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1930973, + "min_ns": 1750451, + "mad_ns": 73603, + "iqr_ns": 199969.0, + "q1_ns": 1800967.0, + "q3_ns": 2000936.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25169920, + "min_bytes": 25169920, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25169920.0, + "q3_bytes": 25169920.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1881726, + 1860413, + 1963707, + 1930973, + 1769621, + 1800967, + 1751695, + 1750451, + 2028180, + 1984301, + 2962699, + 4863974, + 1944761, + 1857370, + 2000936 + ], + "raw_peak_rss_bytes": [ + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920, + 25169920 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 111356211, + "min_ns": 107373920, + "mad_ns": 1126135, + "iqr_ns": 3497959.0, + "q1_ns": 108984387.0, + "q3_ns": 112482346.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 110252366, + 112475467, + 110506760, + 112482346, + 112515451, + 111736382, + 108711994, + 108984387, + 110324207, + 107675191, + 107373920, + 111356211, + 111708750, + 152044229, + 116810477 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 101821034, + "min_ns": 98189363, + "mad_ns": 2515503, + "iqr_ns": 7954418.0, + "q1_ns": 99413052.0, + "q3_ns": 107367470.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 104561530, + 107840392, + 102907242, + 100170584, + 101821034, + 101532626, + 99305531, + 99413052, + 109054003, + 102478990, + 107367470, + 116725680, + 100719714, + 98925646, + 98189363 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 119826082, + "min_ns": 114691728, + "mad_ns": 3960154, + "iqr_ns": 8005976.0, + "q1_ns": 117201246.0, + "q3_ns": 125207222.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 114691728, + 114905410, + 125207222, + 117452991, + 115865928, + 126854168, + 134245243, + 121437123, + 124781919, + 117201246, + 117388440, + 118141832, + 160886923, + 123045678, + 119826082 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 108827502, + "min_ns": 104291165, + "mad_ns": 3284347, + "iqr_ns": 7608638.0, + "q1_ns": 105779046.0, + "q3_ns": 113387684.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 109494113, + 109588907, + 108827502, + 107409231, + 105779046, + 115021147, + 113674702, + 104796410, + 106774325, + 113387684, + 113118101, + 125424041, + 105543155, + 106215389, + 104291165 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 3184934821, + "min_ns": 3096118687, + "mad_ns": 47112713, + "iqr_ns": 134864857.0, + "q1_ns": 3145688472.0, + "q3_ns": 3280553329.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178556928, + "min_bytes": 178061312, + "mad_bytes": 135168, + "iqr_bytes": 290816.0, + "q1_bytes": 178421760.0, + "q3_bytes": 178712576.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3118989906, + 3157243952, + 3184934821, + 3096118687, + 3310109965, + 3350064959, + 3310554341, + 3280553329, + 3209276970, + 3169380463, + 3162949452, + 3145688472, + 3194398286, + 3127462244, + 3232047534 + ], + "raw_peak_rss_bytes": [ + 178712576, + 178421760, + 178647040, + 178061312, + 179154944, + 179208192, + 178655232, + 179085312, + 178458624, + 178520064, + 178577408, + 178307072, + 178556928, + 178327552, + 178462720 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3034811557, + "min_ns": 2925284499, + "mad_ns": 41437054, + "iqr_ns": 86790352.0, + "q1_ns": 2993374503.0, + "q3_ns": 3080164855.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178798592, + "min_bytes": 178446336, + "mad_bytes": 110592, + "iqr_bytes": 266240.0, + "q1_bytes": 178638848.0, + "q3_bytes": 178905088.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2925284499, + 2970463256, + 3080164855, + 3015470525, + 2950246493, + 3034811557, + 3131278692, + 3116071214, + 3147582784, + 3053169805, + 3024712159, + 3042905298, + 3055388040, + 2993374503, + 3019824252 + ], + "raw_peak_rss_bytes": [ + 178786304, + 179089408, + 178806784, + 178446336, + 178798592, + 178872320, + 178573312, + 178688000, + 178831360, + 179027968, + 178569216, + 178724864, + 179077120, + 178638848, + 178905088 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 5982392, + "min_ns": 5544367, + "mad_ns": 259408, + "iqr_ns": 596292.0, + "q1_ns": 5872568.0, + "q3_ns": 6468860.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6475933, + 6095208, + 5903689, + 6494687, + 6241800, + 6168518, + 5872568, + 5629087, + 5937392, + 6958620, + 5982392, + 5544367, + 5960537, + 5619876, + 6468860 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 6256359, + "min_ns": 5616900, + "mad_ns": 199558, + "iqr_ns": 472822.0, + "q1_ns": 5983013.0, + "q3_ns": 6455835.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6824259, + 6455835, + 6194637, + 5973100, + 6056801, + 5616900, + 6473393, + 5983013, + 6151650, + 7010535, + 6336827, + 6348126, + 6256359, + 5962793, + 6320260 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 107913204, + "min_ns": 101827535, + "mad_ns": 4229584, + "iqr_ns": 9167259.0, + "q1_ns": 103683620.0, + "q3_ns": 112850879.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 116630249, + 145564972, + 101827535, + 109238629, + 109346855, + 112850879, + 107913204, + 103118352, + 103683620, + 102426080, + 107018669, + 108790746, + 116388383, + 106069233, + 107694538 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 78336189, + "min_ns": 74048003, + "mad_ns": 2194732, + "iqr_ns": 4769386.0, + "q1_ns": 76141457.0, + "q3_ns": 80910843.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 80079660, + 80910843, + 80503294, + 76504794, + 76481185, + 74048003, + 88330860, + 75985682, + 90368058, + 77638492, + 78336189, + 74940230, + 123569260, + 79472624, + 76141457 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 3131527099, + "min_ns": 2988970725, + "mad_ns": 53658120, + "iqr_ns": 118562804.0, + "q1_ns": 3066622415.0, + "q3_ns": 3185185219.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 178798592, + "min_bytes": 178155520, + "mad_bytes": 245760, + "iqr_bytes": 512000.0, + "q1_bytes": 178552832.0, + "q3_bytes": 179064832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3185185219, + 3193830946, + 3003128949, + 3097350772, + 3252153191, + 3136829250, + 3159861519, + 3131527099, + 3117258443, + 2988970725, + 3137508754, + 3066622415, + 3116563571, + 3050392732, + 3231956858 + ], + "raw_peak_rss_bytes": [ + 178257920, + 178712576, + 179527680, + 178552832, + 179273728, + 178155520, + 178683904, + 178962432, + 178786304, + 178798592, + 179134464, + 179064832, + 178425856, + 178933760, + 178921472 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2001936, + "min_ns": 1859992, + "mad_ns": 63412, + "iqr_ns": 193833.0, + "q1_ns": 1939035.0, + "q3_ns": 2132868.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2001936, + 1996766, + 2388647, + 2168085, + 2018747, + 2107936, + 2297335, + 1945765, + 2041143, + 1938524, + 2132868, + 1893987, + 1859992, + 1969932, + 1939035 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1971916, + "min_ns": 1885541, + "mad_ns": 72453, + "iqr_ns": 323615.0, + "q1_ns": 1911204.0, + "q3_ns": 2234819.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1958216, + 1920938, + 1896388, + 2379529, + 1971916, + 1885541, + 2548362, + 1911204, + 1971067, + 2044748, + 2397601, + 2234819, + 2037085, + 1986968, + 1899463 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1913705, + "min_ns": 1785425, + "mad_ns": 41526, + "iqr_ns": 102044.0, + "q1_ns": 1876201.0, + "q3_ns": 1978245.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1993445, + 1888746, + 1948441, + 1889478, + 1915948, + 1983753, + 1876201, + 1785425, + 1869726, + 1879165, + 1913705, + 1955231, + 1978245, + 1988410, + 1840085 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 104974412, + "min_ns": 100590554, + "mad_ns": 1897301, + "iqr_ns": 3740023.0, + "q1_ns": 103414871.0, + "q3_ns": 107154894.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 103414871, + 102731585, + 104974412, + 107154894, + 105213734, + 102127652, + 100590554, + 143441848, + 104489044, + 111439041, + 106871713, + 107733618, + 104322614, + 106043331, + 103845210 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 117733606, + "min_ns": 112734162, + "mad_ns": 2889813, + "iqr_ns": 8280329.0, + "q1_ns": 115902586.0, + "q3_ns": 124182915.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 129402403, + 115902586, + 124182915, + 119485600, + 116520233, + 114843793, + 114768869, + 125635514, + 112734162, + 123149555, + 126229307, + 117733606, + 119148140, + 116735496, + 116402671 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1843765, + "min_ns": 1719841, + "mad_ns": 61246, + "iqr_ns": 112757.0, + "q1_ns": 1792574.0, + "q3_ns": 1905331.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25174016, + "min_bytes": 25174016, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25174016.0, + "q3_bytes": 25174016.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2185427, + 1800008, + 1816954, + 1858971, + 1843765, + 1792574, + 1752663, + 1910585, + 1905331, + 1934818, + 1843759, + 1866444, + 1719841, + 1905011, + 1781822 + ], + "raw_peak_rss_bytes": [ + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016, + 25174016 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "reproducibility": { + "tag": "CALIBRATION_ONLY", + "earlier_run": { + "path": "p022-263a-calibration-run-a.linux.json", + "sha256": "d0c6f79cd18ebadcd7590400d9b8692553b06765a51837e0d3de238a59441f83", + "bytes": 93618, + "tree_sha": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118", + "tree_dirty": false, + "harness_digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "calibration_repetitions": 15, + "warmup_discards": 2 + }, + "compared_cells": 40, + "tolerance_relative": 0.35, + "tolerance_source": "REPRODUCIBILITY_MAX_MEDIAN_CHANGE, a fixed policy constant. It is CHOSEN, not derived from this run; what makes it admissible is that it was chosen before the runs it judges, and it is not adjusted after seeing which of them it rejects.", + "cells_only_in_earlier": [], + "cells_only_in_later": [], + "cells_outside_tolerance": [ + { + "cell": "core-full-human|rust|cal-facts-small|process-cold", + "relative_change": 0.3955925574118567, + "tolerance": 0.35 + }, + { + "cell": "core-full-sarif|rust|cal-facts-small|warm", + "relative_change": 0.4230650491654784, + "tolerance": 0.35 + }, + { + "cell": "core-usage|rust|cal-facts-tiny|process-cold", + "relative_change": 0.5163410641832393, + "tolerance": 0.35 + } + ], + "cells_whose_outcome_changed": [], + "outcomes_reproduced": true, + "timings_reproduced": false, + "reproduced": false + }, + "admissibility": { + "outcomes_reproduced": true, + "timings_reproduced": false, + "environment_valid": true, + "admissible": false, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/historical/p022-263a-sizing-n5-run-a.linux.json b/docs/evidence/historical/p022-263a-sizing-n5-run-a.linux.json new file mode 100644 index 00000000..99e18574 --- /dev/null +++ b/docs/evidence/historical/p022-263a-sizing-n5-run-a.linux.json @@ -0,0 +1,3133 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "warmup_discards": 2, + "calibration_repetitions": 5, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 attestation on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "harness_digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "python_reference_commit": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118" + }, + "gate_requirements": [ + "the payload declares kind='own.net/p022/d7-freeze-attestation' and schema=1", + "the payload carries every top-level field: kind, schema, payload_sha256, c1, c2", + "the payload carries a complete C1 section: harness_digest, workload_manifest_sha256, python_reference_commit", + "the payload carries a complete C2 section (presence only; the gate never reads a single one of these values): repetitions_ladder, comparison_estimator, thresholds", + "payload_sha256 equals a hash recomputed over the payload's own canonical body", + "C1 matches the identities this process observes", + "a ratification exists at p022-263a-d7-ratification.json, declares kind='own.net/p022/d7-freeze-ratification', and carries: kind, schema, owner, payload_path, payload_commit_sha, ratified_payload_sha256, signature", + "ratified_payload_sha256 equals that same recomputed body hash", + "payload_path is exactly the repository-relative path this instrument reads its payload from — a ratification may not choose which file it is about", + "payload_commit_sha names a commit that exists, and the payload's working-tree bytes are the blob at that path, resolved from the git TREE ROOT, in that commit", + "the ratification is itself committed and unmodified in the working tree", + "signature is exactly \"none\", recorded as unsigned; signed ratification is not part of this version's accepted contract" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T08:05:59Z", + "measurements_taken": 200 + } + }, + "provenance": { + "tree_sha": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118", + "tree_dirty": false, + "python_reference_commit": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.80GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T08:09:26Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 21857587, + "iqr_ns": 656509.5, + "min_ns": 21339704, + "relative_iqr": 0.030035772018201276, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 23048168, + "iqr_ns": 1585517.0, + "min_ns": 22041123, + "relative_iqr": 0.06879145448783608, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2602300, + "min_ns": 2403795, + "mad_ns": 198505, + "iqr_ns": 592965.0, + "q1_ns": 2436268.0, + "q3_ns": 3029233.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25133056, + "min_bytes": 25133056, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25133056.0, + "q3_bytes": 25133056.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3092298, + 2966168, + 2602300, + 2468741, + 2403795 + ], + "raw_peak_rss_bytes": [ + 25133056, + 25133056, + 25133056, + 25133056, + 25133056 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3280868989, + "min_ns": 3207134591, + "mad_ns": 73734398, + "iqr_ns": 281536897.0, + "q1_ns": 3220423797.5, + "q3_ns": 3501960694.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178835456, + "min_bytes": 178556928, + "mad_bytes": 159744, + "iqr_bytes": 1384448.0, + "q1_bytes": 178616320.0, + "q3_bytes": 180000768.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3280868989, + 3584255230, + 3233713004, + 3419666159, + 3207134591 + ], + "raw_peak_rss_bytes": [ + 178835456, + 181116928, + 178675712, + 178884608, + 178556928 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 74874329, + "min_ns": 73205761, + "mad_ns": 1668568, + "iqr_ns": 4108898.0, + "q1_ns": 73941124.0, + "q3_ns": 78050022.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25268224, + "min_bytes": 25268224, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25268224.0, + "q3_bytes": 25268224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 74874329, + 74676487, + 78061511, + 78038533, + 73205761 + ], + "raw_peak_rss_bytes": [ + 25268224, + 25268224, + 25268224, + 25268224, + 25268224 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 100564483, + "min_ns": 94265113, + "mad_ns": 4834386, + "iqr_ns": 18691008.0, + "q1_ns": 94997605.0, + "q3_ns": 113688613.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25268224, + "min_bytes": 25268224, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25268224.0, + "q3_bytes": 25268224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 94265113, + 95730097, + 100564483, + 104849620, + 122527606 + ], + "raw_peak_rss_bytes": [ + 25268224, + 25268224, + 25268224, + 25268224, + 25268224 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3137110864, + "min_ns": 2935447538, + "mad_ns": 201663326, + "iqr_ns": 393491781.0, + "q1_ns": 2994686129.5, + "q3_ns": 3388177910.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 179138560, + "min_bytes": 177954816, + "mad_bytes": 208896, + "iqr_bytes": 854016.0, + "q1_bytes": 178423808.0, + "q3_bytes": 179277824.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3343885693, + 3053924721, + 2935447538, + 3432470128, + 3137110864 + ], + "raw_peak_rss_bytes": [ + 179138560, + 179208192, + 179347456, + 178892800, + 177954816 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 117066911, + "min_ns": 105736519, + "mad_ns": 2121528, + "iqr_ns": 9919136.0, + "q1_ns": 110340951.0, + "q3_ns": 120260087.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25272320, + "min_bytes": 25272320, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25272320.0, + "q3_bytes": 25272320.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 122250735, + 118269439, + 117066911, + 105736519, + 114945383 + ], + "raw_peak_rss_bytes": [ + 25272320, + 25272320, + 25272320, + 25272320, + 25272320 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 113017449, + "min_ns": 109363356, + "mad_ns": 2762392, + "iqr_ns": 5508466.5, + "q1_ns": 109809206.5, + "q3_ns": 115317673.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25272320, + "min_bytes": 25272320, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25272320.0, + "q3_bytes": 25272320.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 109363356, + 113017449, + 116924181, + 110255057, + 113711165 + ], + "raw_peak_rss_bytes": [ + 25272320, + 25272320, + 25272320, + 25272320, + 25272320 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 115277416, + "min_ns": 108242365, + "mad_ns": 2948580, + "iqr_ns": 9519474.5, + "q1_ns": 108485918.0, + "q3_ns": 118005392.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25276416, + "min_bytes": 25276416, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25276416.0, + "q3_bytes": 25276416.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 115277416, + 108242365, + 108729471, + 117784789, + 118225996 + ], + "raw_peak_rss_bytes": [ + 25276416, + 25276416, + 25276416, + 25276416, + 25276416 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3324135915, + "min_ns": 3165728534, + "mad_ns": 14091760, + "iqr_ns": 139963875.5, + "q1_ns": 3238209217.5, + "q3_ns": 3378173093.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178991104, + "min_bytes": 178847744, + "mad_bytes": 61440, + "iqr_bytes": 180224.0, + "q1_bytes": 178905088.0, + "q3_bytes": 179085312.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3324135915, + 3418118511, + 3338227675, + 3310689901, + 3165728534 + ], + "raw_peak_rss_bytes": [ + 179118080, + 179052544, + 178847744, + 178991104, + 178962432 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 99502817, + "min_ns": 98387691, + "mad_ns": 404361, + "iqr_ns": 1424475.5, + "q1_ns": 98407338.0, + "q3_ns": 99831813.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 98426985, + 99907178, + 99756449, + 98387691, + 99502817 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3234141048, + "min_ns": 3102566071, + "mad_ns": 129674038, + "iqr_ns": 256150833.0, + "q1_ns": 3103516540.5, + "q3_ns": 3359667373.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178802688, + "min_bytes": 178708480, + "mad_bytes": 94208, + "iqr_bytes": 376832.0, + "q1_bytes": 178753536.0, + "q3_bytes": 179130368.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3102566071, + 3104467010, + 3234141048, + 3378286258, + 3341048489 + ], + "raw_peak_rss_bytes": [ + 179240960, + 179019776, + 178798592, + 178802688, + 178708480 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2352343, + "min_ns": 2301552, + "mad_ns": 50791, + "iqr_ns": 252752.5, + "q1_ns": 2309104.5, + "q3_ns": 2561857.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2467909, + 2655805, + 2301552, + 2352343, + 2316657 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1939648, + "min_ns": 1737660, + "mad_ns": 24592, + "iqr_ns": 161685.5, + "q1_ns": 1800939.0, + "q3_ns": 1962624.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1864218, + 1961009, + 1964240, + 1939648, + 1737660 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 116406017, + "min_ns": 113306997, + "mad_ns": 774106, + "iqr_ns": 3142387.5, + "q1_ns": 114469454.0, + "q3_ns": 117611841.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 116406017, + 113306997, + 118503293, + 115631911, + 116720390 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 6105618, + "min_ns": 5915676, + "mad_ns": 139695, + "iqr_ns": 246438.0, + "q1_ns": 5940799.5, + "q3_ns": 6187237.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6110849, + 6105618, + 5965923, + 6263626, + 5915676 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1931975, + "min_ns": 1819015, + "mad_ns": 42536, + "iqr_ns": 103408.5, + "q1_ns": 1872521.5, + "q3_ns": 1975930.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1974511, + 1931975, + 1926028, + 1819015, + 1977349 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 6308924, + "min_ns": 6001076, + "mad_ns": 307848, + "iqr_ns": 972798.5, + "q1_ns": 6075296.0, + "q3_ns": 7048094.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6841411, + 6308924, + 7254778, + 6001076, + 6149516 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2328288, + "min_ns": 2282421, + "mad_ns": 45867, + "iqr_ns": 135752.5, + "q1_ns": 2292173.5, + "q3_ns": 2427926.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25288704, + "min_bytes": 25288704, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25288704.0, + "q3_bytes": 25288704.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2328288, + 2434613, + 2301926, + 2421239, + 2282421 + ], + "raw_peak_rss_bytes": [ + 25288704, + 25288704, + 25288704, + 25288704, + 25288704 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 105261515, + "min_ns": 102298320, + "mad_ns": 2963195, + "iqr_ns": 5591042.5, + "q1_ns": 103541368.5, + "q3_ns": 109132411.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25288704, + "min_bytes": 25288704, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25288704.0, + "q3_bytes": 25288704.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 102298320, + 105261515, + 104784417, + 109638392, + 108626430 + ], + "raw_peak_rss_bytes": [ + 25288704, + 25288704, + 25288704, + 25288704, + 25288704 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2331933, + "min_ns": 2303349, + "mad_ns": 28584, + "iqr_ns": 111611.5, + "q1_ns": 2313274.0, + "q3_ns": 2424885.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25288704, + "min_bytes": 25288704, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25288704.0, + "q3_bytes": 25288704.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2331933, + 2303349, + 2444155, + 2323199, + 2405616 + ], + "raw_peak_rss_bytes": [ + 25288704, + 25288704, + 25288704, + 25288704, + 25288704 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1832760, + "min_ns": 1710921, + "mad_ns": 113245, + "iqr_ns": 242642.0, + "q1_ns": 1715218.0, + "q3_ns": 1957860.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25288704, + "min_bytes": 25288704, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25288704.0, + "q3_bytes": 25288704.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1990948, + 1710921, + 1832760, + 1719515, + 1924772 + ], + "raw_peak_rss_bytes": [ + 25288704, + 25288704, + 25288704, + 25288704, + 25288704 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3082414390, + "min_ns": 2990221630, + "mad_ns": 92192760, + "iqr_ns": 315221977.5, + "q1_ns": 3032334732.5, + "q3_ns": 3347556710.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178999296, + "min_bytes": 178741248, + "mad_bytes": 258048, + "iqr_bytes": 569344.0, + "q1_bytes": 178755584.0, + "q3_bytes": 179324928.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2990221630, + 3082414390, + 3074447835, + 3226555855, + 3468557565 + ], + "raw_peak_rss_bytes": [ + 179306496, + 178769920, + 179343360, + 178741248, + 178999296 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2109923, + "min_ns": 1930685, + "mad_ns": 85525, + "iqr_ns": 229584.0, + "q1_ns": 1930715.5, + "q3_ns": 2160299.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25288704, + "min_bytes": 25288704, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25288704.0, + "q3_bytes": 25288704.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2125151, + 2109923, + 1930746, + 1930685, + 2195448 + ], + "raw_peak_rss_bytes": [ + 25288704, + 25288704, + 25288704, + 25288704, + 25288704 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 125642339, + "min_ns": 120281954, + "mad_ns": 2616237, + "iqr_ns": 6998563.5, + "q1_ns": 120292331.0, + "q3_ns": 127290894.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25292800, + "min_bytes": 25292800, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25292800.0, + "q3_bytes": 25292800.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 128258576, + 120281954, + 126323213, + 120302708, + 125642339 + ], + "raw_peak_rss_bytes": [ + 25292800, + 25292800, + 25292800, + 25292800, + 25292800 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 110715691, + "min_ns": 107114128, + "mad_ns": 1197900, + "iqr_ns": 4192596.5, + "q1_ns": 108879251.5, + "q3_ns": 113071848.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25292800, + "min_bytes": 25292800, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25292800.0, + "q3_bytes": 25292800.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 114230105, + 110644375, + 110715691, + 111913591, + 107114128 + ], + "raw_peak_rss_bytes": [ + 25292800, + 25292800, + 25292800, + 25292800, + 25292800 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 122732358, + "min_ns": 121459044, + "mad_ns": 1273314, + "iqr_ns": 13206495.5, + "q1_ns": 121929510.0, + "q3_ns": 135136005.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25292800, + "min_bytes": 25292800, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25292800.0, + "q3_bytes": 25292800.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 122399976, + 142537481, + 127734530, + 121459044, + 122732358 + ], + "raw_peak_rss_bytes": [ + 25292800, + 25292800, + 25292800, + 25292800, + 25292800 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 114200876, + "min_ns": 108678623, + "mad_ns": 574673, + "iqr_ns": 3675575.0, + "q1_ns": 111152413.0, + "q3_ns": 114827988.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25292800, + "min_bytes": 25292800, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25292800.0, + "q3_bytes": 25292800.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 114200876, + 114520184, + 108678623, + 115135792, + 113626203 + ], + "raw_peak_rss_bytes": [ + 25292800, + 25292800, + 25292800, + 25292800, + 25292800 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3308477665, + "min_ns": 3165066355, + "mad_ns": 62475173, + "iqr_ns": 164910150.5, + "q1_ns": 3212694281.0, + "q3_ns": 3377604431.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178479104, + "min_bytes": 178249728, + "mad_bytes": 229376, + "iqr_bytes": 851968.0, + "q1_bytes": 178350080.0, + "q3_bytes": 179202048.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3370952838, + 3308477665, + 3260322207, + 3165066355, + 3384256025 + ], + "raw_peak_rss_bytes": [ + 178933760, + 179470336, + 178450432, + 178479104, + 178249728 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3251391222, + "min_ns": 3041301855, + "mad_ns": 56415532, + "iqr_ns": 230021559.5, + "q1_ns": 3070231639.5, + "q3_ns": 3300253199.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178937856, + "min_bytes": 177819648, + "mad_bytes": 77824, + "iqr_bytes": 917504.0, + "q1_bytes": 178339840.0, + "q3_bytes": 179257344.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3307806754, + 3251391222, + 3292699644, + 3099161424, + 3041301855 + ], + "raw_peak_rss_bytes": [ + 179539968, + 178974720, + 177819648, + 178937856, + 178860032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 6240977, + "min_ns": 6051827, + "mad_ns": 109936, + "iqr_ns": 282347.0, + "q1_ns": 6102003.5, + "q3_ns": 6384350.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25292800, + "min_bytes": 25292800, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25292800.0, + "q3_bytes": 25292800.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6350913, + 6417788, + 6051827, + 6240977, + 6152180 + ], + "raw_peak_rss_bytes": [ + 25292800, + 25292800, + 25292800, + 25292800, + 25292800 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 5984908, + "min_ns": 5912625, + "mad_ns": 58212, + "iqr_ns": 150685.0, + "q1_ns": 5942034.5, + "q3_ns": 6092719.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25292800, + "min_bytes": 25292800, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25292800.0, + "q3_bytes": 25292800.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6043120, + 5971444, + 5984908, + 5912625, + 6142319 + ], + "raw_peak_rss_bytes": [ + 25292800, + 25292800, + 25292800, + 25292800, + 25292800 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 114239325, + "min_ns": 107261524, + "mad_ns": 910439, + "iqr_ns": 5245457.5, + "q1_ns": 110410228.0, + "q3_ns": 115655685.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 113558932, + 107261524, + 116161607, + 115149764, + 114239325 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 85079420, + "min_ns": 82808163, + "mad_ns": 2230649, + "iqr_ns": 3887503.0, + "q1_ns": 82828467.0, + "q3_ns": 86715970.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 82848771, + 85102175, + 85079420, + 82808163, + 88329765 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3338013680, + "min_ns": 3195855356, + "mad_ns": 83735548, + "iqr_ns": 187667527.5, + "q1_ns": 3217438403.5, + "q3_ns": 3405105931.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178741248, + "min_bytes": 178532352, + "mad_bytes": 172032, + "iqr_bytes": 389120.0, + "q1_bytes": 178634752.0, + "q3_bytes": 179023872.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3338013680, + 3421749228, + 3239021451, + 3195855356, + 3388462634 + ], + "raw_peak_rss_bytes": [ + 178532352, + 179134464, + 178737152, + 178913280, + 178741248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2289652, + "min_ns": 2184030, + "mad_ns": 104521, + "iqr_ns": 179525.5, + "q1_ns": 2184580.5, + "q3_ns": 2364106.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2184030, + 2185131, + 2289652, + 2398380, + 2329832 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2117738, + "min_ns": 2038661, + "mad_ns": 31998, + "iqr_ns": 83082.0, + "q1_ns": 2056091.5, + "q3_ns": 2139173.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2117738, + 2149736, + 2128611, + 2073522, + 2038661 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2292127, + "min_ns": 2059321, + "mad_ns": 169554, + "iqr_ns": 354617.5, + "q1_ns": 2165733.5, + "q3_ns": 2520351.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2272146, + 2059321, + 2579021, + 2292127, + 2461681 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 109932808, + "min_ns": 102952128, + "mad_ns": 1311981, + "iqr_ns": 5191693.5, + "q1_ns": 105764413.0, + "q3_ns": 110956106.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 110667424, + 109932808, + 111244789, + 102952128, + 108576698 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 120154534, + "min_ns": 113749689, + "mad_ns": 2654123, + "iqr_ns": 6951240.0, + "q1_ns": 115625050.0, + "q3_ns": 122576290.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 123527359, + 120154534, + 117500411, + 113749689, + 121625221 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2053347, + "min_ns": 1961436, + "mad_ns": 91911, + "iqr_ns": 280478.5, + "q1_ns": 2003567.0, + "q3_ns": 2284045.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25300992, + "min_bytes": 25300992, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25300992.0, + "q3_bytes": 25300992.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2045698, + 2053347, + 2341020, + 2227071, + 1961436 + ], + "raw_peak_rss_bytes": [ + 25300992, + 25300992, + 25300992, + 25300992, + 25300992 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "admissibility": { + "outcomes_reproduced": null, + "timings_reproduced": null, + "environment_valid": true, + "admissible": false, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/historical/p022-263a-sizing-n5.linux.json b/docs/evidence/historical/p022-263a-sizing-n5.linux.json new file mode 100644 index 00000000..b6a40dc1 --- /dev/null +++ b/docs/evidence/historical/p022-263a-sizing-n5.linux.json @@ -0,0 +1,3162 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "warmup_discards": 2, + "calibration_repetitions": 5, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 attestation on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "harness_digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "python_reference_commit": "742dad7483f9b3f998dc131f9233781bd4d4960d" + }, + "gate_requirements": [ + "the payload declares kind='own.net/p022/d7-freeze-attestation' and schema=1", + "the payload carries every top-level field: kind, schema, payload_sha256, c1, c2", + "the payload carries a complete C1 section: harness_digest, workload_manifest_sha256, python_reference_commit", + "the payload carries a complete C2 section (presence only; the gate never reads a single one of these values): repetitions_ladder, comparison_estimator, thresholds", + "payload_sha256 equals a hash recomputed over the payload's own canonical body", + "C1 matches the identities this process observes", + "a ratification exists at p022-263a-d7-ratification.json, declares kind='own.net/p022/d7-freeze-ratification', and carries: kind, schema, owner, payload_path, payload_commit_sha, ratified_payload_sha256, signature", + "ratified_payload_sha256 equals that same recomputed body hash", + "payload_path is exactly the repository-relative path this instrument reads its payload from — a ratification may not choose which file it is about", + "payload_commit_sha names a commit that exists, and the payload's working-tree bytes are the blob at that path, resolved from the git TREE ROOT, in that commit", + "the ratification is itself committed and unmodified in the working tree", + "signature is exactly \"none\", recorded as unsigned; signed ratification is not part of this version's accepted contract" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T08:17:32Z", + "measurements_taken": 200 + } + }, + "provenance": { + "tree_sha": "742dad7483f9b3f998dc131f9233781bd4d4960d", + "tree_dirty": false, + "python_reference_commit": "742dad7483f9b3f998dc131f9233781bd4d4960d", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.80GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T08:20:53Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 21455740, + "iqr_ns": 291093.5, + "min_ns": 20981465, + "relative_iqr": 0.013567161980896487, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 22514148, + "iqr_ns": 868139.5, + "min_ns": 21968144, + "relative_iqr": 0.03855973141866172, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2873108, + "min_ns": 2448330, + "mad_ns": 322670, + "iqr_ns": 713431.5, + "q1_ns": 2499384.0, + "q3_ns": 3212815.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25145344, + "min_bytes": 25145344, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25145344.0, + "q3_bytes": 25145344.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3513063, + 2550438, + 2873108, + 2448330, + 2912568 + ], + "raw_peak_rss_bytes": [ + 25145344, + 25145344, + 25145344, + 25145344, + 25145344 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3102808283, + "min_ns": 3073570406, + "mad_ns": 29237877, + "iqr_ns": 209595426.5, + "q1_ns": 3081113276.0, + "q3_ns": 3290708702.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178761728, + "min_bytes": 178376704, + "mad_bytes": 151552, + "iqr_bytes": 436224.0, + "q1_bytes": 178556928.0, + "q3_bytes": 178993152.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3298196624, + 3283220781, + 3102808283, + 3073570406, + 3088656146 + ], + "raw_peak_rss_bytes": [ + 178376704, + 178761728, + 178737152, + 178913280, + 179073024 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 75714844, + "min_ns": 74145078, + "mad_ns": 1314785, + "iqr_ns": 9101427.0, + "q1_ns": 74272568.5, + "q3_ns": 83373995.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25145344, + "min_bytes": 25145344, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25145344.0, + "q3_bytes": 25145344.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 76450275, + 74145078, + 90297716, + 75714844, + 74400059 + ], + "raw_peak_rss_bytes": [ + 25145344, + 25145344, + 25145344, + 25145344, + 25145344 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 110053358, + "min_ns": 103907002, + "mad_ns": 2927724, + "iqr_ns": 9611648.0, + "q1_ns": 105921300.5, + "q3_ns": 115532948.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25145344, + "min_bytes": 25145344, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25145344.0, + "q3_bytes": 25145344.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 103907002, + 110053358, + 118084815, + 112981082, + 107935599 + ], + "raw_peak_rss_bytes": [ + 25145344, + 25145344, + 25145344, + 25145344, + 25145344 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3020487546, + "min_ns": 2970538989, + "mad_ns": 21669643, + "iqr_ns": 51973972.5, + "q1_ns": 2981305470.0, + "q3_ns": 3033279442.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178991104, + "min_bytes": 178442240, + "mad_bytes": 65536, + "iqr_bytes": 575488.0, + "q1_bytes": 178456576.0, + "q3_bytes": 179032064.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2992071951, + 2970538989, + 3020487546, + 3042157189, + 3024401696 + ], + "raw_peak_rss_bytes": [ + 178442240, + 178470912, + 178991104, + 179007488, + 179056640 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 107964784, + "min_ns": 105297161, + "mad_ns": 1613042, + "iqr_ns": 12689180.5, + "q1_ns": 106104559.5, + "q3_ns": 118793740.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 105297161, + 107964784, + 106911958, + 128009654, + 109577826 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 107265613, + "min_ns": 105548281, + "mad_ns": 1717332, + "iqr_ns": 4968994.5, + "q1_ns": 105553451.5, + "q3_ns": 110522446.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 105548281, + 111000695, + 110044197, + 105558622, + 107265613 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 117423878, + "min_ns": 112426326, + "mad_ns": 2953980, + "iqr_ns": 9135937.5, + "q1_ns": 113552655.0, + "q3_ns": 122688592.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 117423878, + 120377858, + 114678984, + 112426326, + 124999327 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3258933789, + "min_ns": 3169215117, + "mad_ns": 81484382, + "iqr_ns": 151748925.5, + "q1_ns": 3173332262.0, + "q3_ns": 3325081187.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178892800, + "min_bytes": 178536448, + "mad_bytes": 196608, + "iqr_bytes": 1286144.0, + "q1_bytes": 178704384.0, + "q3_bytes": 179990528.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3302349298, + 3258933789, + 3347813077, + 3177449407, + 3169215117 + ], + "raw_peak_rss_bytes": [ + 178872320, + 179089408, + 178892800, + 178536448, + 180891648 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 102748368, + "min_ns": 101332895, + "mad_ns": 923600, + "iqr_ns": 18874605.0, + "q1_ns": 101578831.5, + "q3_ns": 120453436.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 101824768, + 101332895, + 103100234, + 137806639, + 102748368 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3223608224, + "min_ns": 3029129400, + "mad_ns": 106201151, + "iqr_ns": 443815664.5, + "q1_ns": 3084208493.0, + "q3_ns": 3528024157.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178798592, + "min_bytes": 178638848, + "mad_bytes": 73728, + "iqr_bytes": 208896.0, + "q1_bytes": 178649088.0, + "q3_bytes": 178857984.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3329809375, + 3029129400, + 3139287586, + 3223608224, + 3726238940 + ], + "raw_peak_rss_bytes": [ + 178638848, + 178798592, + 178659328, + 178843648, + 178872320 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2569073, + "min_ns": 2247862, + "mad_ns": 15284, + "iqr_ns": 196419.0, + "q1_ns": 2400825.5, + "q3_ns": 2597244.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2571602, + 2553789, + 2247862, + 2622887, + 2569073 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1883229, + "min_ns": 1801807, + "mad_ns": 63221, + "iqr_ns": 132345.0, + "q1_ns": 1823018.5, + "q3_ns": 1955363.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1964277, + 1946450, + 1844230, + 1801807, + 1883229 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 111283205, + "min_ns": 108435133, + "mad_ns": 2265602, + "iqr_ns": 3981000.0, + "q1_ns": 108726368.0, + "q3_ns": 112707368.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 111283205, + 109017603, + 111447699, + 108435133, + 113967037 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 6032104, + "min_ns": 5597779, + "mad_ns": 92500, + "iqr_ns": 890468.0, + "q1_ns": 5768691.5, + "q3_ns": 6659159.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5939604, + 5597779, + 7264052, + 6032104, + 6054267 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1824271, + "min_ns": 1674323, + "mad_ns": 43240, + "iqr_ns": 176244.5, + "q1_ns": 1686201.0, + "q3_ns": 1862445.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1824271, + 1674323, + 1867511, + 1857380, + 1698079 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 5957810, + "min_ns": 5519135, + "mad_ns": 181586, + "iqr_ns": 437665.5, + "q1_ns": 5647679.5, + "q3_ns": 6085345.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5957810, + 5519135, + 6183592, + 5776224, + 5987098 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2446966, + "min_ns": 2358735, + "mad_ns": 75706, + "iqr_ns": 434138.5, + "q1_ns": 2380357.0, + "q3_ns": 2814495.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2401979, + 3106319, + 2522672, + 2446966, + 2358735 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 102560945, + "min_ns": 99698093, + "mad_ns": 652454, + "iqr_ns": 2762122.5, + "q1_ns": 101067163.0, + "q3_ns": 103829285.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 102436233, + 103213399, + 99698093, + 102560945, + 104445172 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2371480, + "min_ns": 2283588, + "mad_ns": 66929, + "iqr_ns": 139741.0, + "q1_ns": 2294069.5, + "q3_ns": 2433810.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2371480, + 2283588, + 2487641, + 2304551, + 2379980 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1851249, + "min_ns": 1720874, + "mad_ns": 130375, + "iqr_ns": 389633.5, + "q1_ns": 1754561.0, + "q3_ns": 2144194.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25260032, + "min_bytes": 25260032, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25260032.0, + "q3_bytes": 25260032.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1851249, + 1788248, + 2028108, + 1720874, + 2260281 + ], + "raw_peak_rss_bytes": [ + 25260032, + 25260032, + 25260032, + 25260032, + 25260032 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3070365104, + "min_ns": 3051625432, + "mad_ns": 18739672, + "iqr_ns": 97420130.0, + "q1_ns": 3058048901.5, + "q3_ns": 3155469031.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178905088, + "min_bytes": 178679808, + "mad_bytes": 217088, + "iqr_bytes": 397312.0, + "q1_bytes": 178681856.0, + "q3_bytes": 179079168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3118354386, + 3070365104, + 3064472371, + 3051625432, + 3192583677 + ], + "raw_peak_rss_bytes": [ + 179036160, + 178905088, + 178679808, + 178683904, + 179122176 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1961453, + "min_ns": 1823829, + "mad_ns": 65974, + "iqr_ns": 186845.0, + "q1_ns": 1873010.5, + "q3_ns": 2059855.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25264128, + "min_bytes": 25264128, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25264128.0, + "q3_bytes": 25264128.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2092284, + 2027427, + 1922192, + 1961453, + 1823829 + ], + "raw_peak_rss_bytes": [ + 25264128, + 25264128, + 25264128, + 25264128, + 25264128 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 117875877, + "min_ns": 112945993, + "mad_ns": 4929884, + "iqr_ns": 18300613.5, + "q1_ns": 113072648.5, + "q3_ns": 131373262.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25268224, + "min_bytes": 25268224, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25268224.0, + "q3_bytes": 25268224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 113199304, + 117875877, + 136085802, + 112945993, + 126660722 + ], + "raw_peak_rss_bytes": [ + 25268224, + 25268224, + 25268224, + 25268224, + 25268224 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 103175352, + "min_ns": 100376452, + "mad_ns": 1080906, + "iqr_ns": 4919668.5, + "q1_ns": 101687276.0, + "q3_ns": 106606944.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25268224, + "min_bytes": 25268224, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25268224.0, + "q3_bytes": 25268224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 104256258, + 103175352, + 100376452, + 108957631, + 102998100 + ], + "raw_peak_rss_bytes": [ + 25268224, + 25268224, + 25268224, + 25268224, + 25268224 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 113455800, + "min_ns": 110677562, + "mad_ns": 1791211, + "iqr_ns": 4783360.5, + "q1_ns": 111439268.0, + "q3_ns": 116222628.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25268224, + "min_bytes": 25268224, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25268224.0, + "q3_bytes": 25268224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 113455800, + 110677562, + 117198246, + 112200974, + 115247011 + ], + "raw_peak_rss_bytes": [ + 25268224, + 25268224, + 25268224, + 25268224, + 25268224 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 102190190, + "min_ns": 99518688, + "mad_ns": 2671502, + "iqr_ns": 7006190.5, + "q1_ns": 100122051.0, + "q3_ns": 107128241.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25268224, + "min_bytes": 25268224, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25268224.0, + "q3_bytes": 25268224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 99518688, + 100725414, + 102190190, + 105778281, + 108478202 + ], + "raw_peak_rss_bytes": [ + 25268224, + 25268224, + 25268224, + 25268224, + 25268224 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 3153865436, + "min_ns": 3098024372, + "mad_ns": 55841064, + "iqr_ns": 111208223.0, + "q1_ns": 3112391225.0, + "q3_ns": 3223599448.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178487296, + "min_bytes": 178302976, + "mad_bytes": 184320, + "iqr_bytes": 458752.0, + "q1_bytes": 178317312.0, + "q3_bytes": 178776064.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3153865436, + 3126758078, + 3237171174, + 3098024372, + 3210027722 + ], + "raw_peak_rss_bytes": [ + 178331648, + 178302976, + 178712576, + 178839552, + 178487296 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3185315981, + "min_ns": 2963664663, + "mad_ns": 74946360, + "iqr_ns": 240377888.5, + "q1_ns": 2984633316.0, + "q3_ns": 3225011204.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178835456, + "min_bytes": 178130944, + "mad_bytes": 204800, + "iqr_bytes": 782336.0, + "q1_bytes": 178380800.0, + "q3_bytes": 179163136.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3185315981, + 3260262341, + 3189760068, + 3005601969, + 2963664663 + ], + "raw_peak_rss_bytes": [ + 178921472, + 178130944, + 178630656, + 178835456, + 179404800 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 9223322, + "min_ns": 5493226, + "mad_ns": 557884, + "iqr_ns": 4115118.5, + "q1_ns": 5622851.5, + "q3_ns": 9737970.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25272320, + "min_bytes": 25272320, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25272320.0, + "q3_bytes": 25272320.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 9223322, + 5752477, + 9781206, + 5493226, + 9694734 + ], + "raw_peak_rss_bytes": [ + 25272320, + 25272320, + 25272320, + 25272320, + 25272320 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 5474301, + "min_ns": 5423718, + "mad_ns": 50583, + "iqr_ns": 212320.5, + "q1_ns": 5433619.5, + "q3_ns": 5645940.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5613183, + 5474301, + 5678697, + 5443521, + 5423718 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 101691758, + "min_ns": 98799164, + "mad_ns": 2435426, + "iqr_ns": 5741495.5, + "q1_ns": 99027748.0, + "q3_ns": 104769243.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 101691758, + 107305683, + 102232804, + 98799164, + 99256332 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 74356656, + "min_ns": 72745457, + "mad_ns": 58948, + "iqr_ns": 1132882.5, + "q1_ns": 73524204.0, + "q3_ns": 74657086.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 72745457, + 74415604, + 74302951, + 74356656, + 74898569 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 3167628251, + "min_ns": 3096182462, + "mad_ns": 33370154, + "iqr_ns": 84642775.0, + "q1_ns": 3107502936.0, + "q3_ns": 3192145711.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 178806784, + "min_bytes": 178044928, + "mad_bytes": 159744, + "iqr_bytes": 604160.0, + "q1_bytes": 178321408.0, + "q3_bytes": 178925568.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 3118823410, + 3167628251, + 3200998405, + 3096182462, + 3183293017 + ], + "raw_peak_rss_bytes": [ + 178044928, + 178884608, + 178597888, + 178806784, + 178966528 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1941707, + "min_ns": 1837759, + "mad_ns": 103948, + "iqr_ns": 271509.0, + "q1_ns": 1874806.0, + "q3_ns": 2146315.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1941707, + 1837759, + 2050316, + 1911853, + 2242314 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1877172, + "min_ns": 1775548, + "mad_ns": 101624, + "iqr_ns": 1618978.0, + "q1_ns": 1824737.0, + "q3_ns": 3443715.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1775548, + 2196166, + 1877172, + 4691264, + 1873926 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2270438, + "min_ns": 2074137, + "mad_ns": 196301, + "iqr_ns": 449749.5, + "q1_ns": 2111439.5, + "q3_ns": 2561189.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2522227, + 2600151, + 2148742, + 2270438, + 2074137 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 100164029, + "min_ns": 98219443, + "mad_ns": 1885209, + "iqr_ns": 3477916.5, + "q1_ns": 98940356.0, + "q3_ns": 102418272.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25280512, + "min_bytes": 25280512, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25280512.0, + "q3_bytes": 25280512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 100164029, + 99661269, + 102049238, + 98219443, + 102787307 + ], + "raw_peak_rss_bytes": [ + 25280512, + 25280512, + 25280512, + 25280512, + 25280512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 115862077, + "min_ns": 115067939, + "mad_ns": 794138, + "iqr_ns": 6458433.0, + "q1_ns": 115299398.5, + "q3_ns": 121757831.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 122074980, + 115530858, + 121440683, + 115067939, + 115862077 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1855983, + "min_ns": 1841459, + "mad_ns": 14524, + "iqr_ns": 139931.5, + "q1_ns": 1847217.5, + "q3_ns": 1987149.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25284608, + "min_bytes": 25284608, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25284608.0, + "q3_bytes": 25284608.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2014222, + 1855983, + 1960076, + 1852976, + 1841459 + ], + "raw_peak_rss_bytes": [ + 25284608, + 25284608, + 25284608, + 25284608, + 25284608 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "reproducibility": { + "tag": "CALIBRATION_ONLY", + "earlier_run": { + "path": "p022-263a-sizing-n5-run-a.linux.json", + "sha256": "69fb665dd04d6e103a8454770f3459c5272d58f0a1b2093ffbd65e5f6742bcce", + "bytes": 78956, + "tree_sha": "6c33e2a07f0c7f4c4d21e9b8cb0d0c0e3ab47118", + "tree_dirty": false, + "harness_digest": "8450224cbeaa078ebba06503e0f54c865e65b42a998eefda40dacf6b7bdc4e56", + "calibration_repetitions": 5, + "warmup_discards": 2 + }, + "compared_cells": 40, + "tolerance_relative": 0.35, + "tolerance_source": "REPRODUCIBILITY_MAX_MEDIAN_CHANGE, a fixed policy constant. It is CHOSEN, not derived from this run; what makes it admissible is that it was chosen before the runs it judges, and it is not adjusted after seeing which of them it rejects.", + "cells_only_in_earlier": [], + "cells_only_in_later": [], + "cells_outside_tolerance": [ + { + "cell": "core-full-sarif|rust|cal-facts-medium|process-cold", + "relative_change": 0.47786508426485147, + "tolerance": 0.35 + } + ], + "cells_whose_outcome_changed": [], + "outcomes_reproduced": true, + "timings_reproduced": false, + "reproduced": false + }, + "admissibility": { + "outcomes_reproduced": true, + "timings_reproduced": false, + "environment_valid": true, + "admissible": false, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/p022-263a-sizing-n15-run-a.linux.json b/docs/evidence/p022-263a-sizing-n15-run-a.linux.json new file mode 100644 index 00000000..c07e0f8d --- /dev/null +++ b/docs/evidence/p022-263a-sizing-n15-run-a.linux.json @@ -0,0 +1,3935 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "warmup_discards": 2, + "calibration_repetitions": 15, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 payload on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "harness_digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "harness_version": "1", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a" + }, + "gate_requirements": [ + "C1: a payload at p022-263a-d7-payload.json declaring kind='own.net/p022/d7-payload', carrying kind, schema, cells, rollups, instrument_anchor_commit, python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256, ratification", + "C1 carries a STRUCTURALLY COMPLETE preregistration: cells, rollups; each cell declares phase, workload_id, platform, regime and either bound, pass_fail_rule, inconclusive_band, repetition_ladder, comparison_statistic, rss_policy, allocation_policy (the ladder carrying initial_n, escalation_stages, transition_predicates, max_n, terminal_outcome) or an explicit not_applicable naming a reason in words; roll-ups carry workload_class, phase, overall_g3. Values are never read", + "C1 decides EVERY one of the 384 cells D7 covers — phase x workload_id x platform x regime over the frozen decisive manifest with aliases resolved — with no cell missing, unknown, or named twice", + "C1 declares instrument_anchor_commit S, and the instrument AT S hashes to the harness_digest C1 froze; S is an ancestor of C1. The CURRENT position is never required to equal S, because by #263-B it cannot be", + "C1's bindings equal what this process observes: python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256", + "C2: a detached attestation at p022-263a-d7-attestation.json declaring kind='own.net/p022/d7-attestation', carrying kind, schema, payload_path, payload_commit_sha, payload_blob_sha, payload_sha256, bindings, ratification_binding", + "C2's payload_sha256 equals the sha256 of the payload's EXACT BYTES", + "C2's payload_blob_sha equals the git blob sha of the payload at payload_commit_sha, and the payload's working-tree bytes are that blob", + "C2's own commit is a strict DESCENDANT of payload_commit_sha", + "C2's bindings and ratification_binding equal C1's", + "both objects are committed and unmodified in the working tree" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T15:58:38Z", + "measurements_taken": 600 + } + }, + "provenance": { + "tree_sha": "843d6fecfb38b2cf91f13ec179086f96705d7a88", + "tree_dirty": false, + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.10GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T16:04:48Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 14382157, + "iqr_ns": 760458.5, + "min_ns": 13700218, + "relative_iqr": 0.05287513548906468, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 14480097, + "iqr_ns": 450159.5, + "min_ns": 13865384, + "relative_iqr": 0.031088155003381537, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2232196, + "min_ns": 2034154, + "mad_ns": 146028, + "iqr_ns": 529459.0, + "q1_ns": 2126054.0, + "q3_ns": 2655513.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25845760, + "min_bytes": 25845760, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25845760.0, + "q3_bytes": 25845760.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2655513, + 2065367, + 2776844, + 2034154, + 2126054, + 2800253, + 2139971, + 2378224, + 2179460, + 2747269, + 2211326, + 2232196, + 2612495, + 2241731, + 2107103 + ], + "raw_peak_rss_bytes": [ + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760, + 25845760 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2493462330, + "min_ns": 2361937012, + "mad_ns": 31108254, + "iqr_ns": 63807507.0, + "q1_ns": 2460763077.0, + "q3_ns": 2524570584.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213094400, + "min_bytes": 203898880, + "mad_bytes": 724992, + "iqr_bytes": 9609216.0, + "q1_bytes": 204029952.0, + "q3_bytes": 213639168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2555646620, + 2361937012, + 2471345658, + 2493462330, + 2654086297, + 2517145139, + 2509508521, + 2564066149, + 2524570584, + 2494391079, + 2493360963, + 2438951487, + 2475179253, + 2460763077, + 2448913849 + ], + "raw_peak_rss_bytes": [ + 212582400, + 203902976, + 213639168, + 213209088, + 204058624, + 214364160, + 213094400, + 204029952, + 214245376, + 212647936, + 213471232, + 203960320, + 213471232, + 213819392, + 203898880 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 65232253, + "min_ns": 62206726, + "mad_ns": 1659384, + "iqr_ns": 3189170.0, + "q1_ns": 64612751.0, + "q3_ns": 67801921.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25964544, + "min_bytes": 25964544, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25964544.0, + "q3_bytes": 25964544.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 65069988, + 66781282, + 71897689, + 67801921, + 66891637, + 81044391, + 65232253, + 65747629, + 64612751, + 62543294, + 62206726, + 64860533, + 63284844, + 65138026, + 90681594 + ], + "raw_peak_rss_bytes": [ + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544, + 25964544 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 86051869, + "min_ns": 83296855, + "mad_ns": 2014312, + "iqr_ns": 4036899.0, + "q1_ns": 84029282.0, + "q3_ns": 88066181.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25972736, + "min_bytes": 25972736, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25972736.0, + "q3_bytes": 25972736.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84734744, + 84090310, + 84163742, + 83296855, + 86737463, + 86051869, + 83416514, + 86054834, + 99251132, + 88066181, + 91740057, + 88869364, + 83450965, + 84029282, + 87807044 + ], + "raw_peak_rss_bytes": [ + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736, + 25972736 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2413540351, + "min_ns": 2280897364, + "mad_ns": 19869350, + "iqr_ns": 120917240.0, + "q1_ns": 2400521927.0, + "q3_ns": 2521439167.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213073920, + "min_bytes": 203661312, + "mad_bytes": 802816, + "iqr_bytes": 9793536.0, + "q1_bytes": 203915264.0, + "q3_bytes": 213708800.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2570167495, + 2393671001, + 2405225164, + 2419976281, + 2414932783, + 2280897364, + 2461630386, + 2521439167, + 2413540351, + 2408576421, + 2343505966, + 2551527472, + 2550413084, + 2410348552, + 2400521927 + ], + "raw_peak_rss_bytes": [ + 213278720, + 203915264, + 213708800, + 203771904, + 214208512, + 203796480, + 213512192, + 212971520, + 204578816, + 213745664, + 204083200, + 213876736, + 213073920, + 213286912, + 203661312 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 88096527, + "min_ns": 82892392, + "mad_ns": 2282910, + "iqr_ns": 5023956.0, + "q1_ns": 85355481.0, + "q3_ns": 90379437.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25976832, + "min_bytes": 25976832, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25976832.0, + "q3_bytes": 25976832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 88857345, + 84834471, + 88945543, + 85355481, + 88096527, + 85860288, + 86578837, + 84242264, + 87924077, + 92997185, + 99834683, + 90379437, + 90389782, + 88780808, + 82892392 + ], + "raw_peak_rss_bytes": [ + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 94753154, + "min_ns": 85935951, + "mad_ns": 5305886, + "iqr_ns": 11404849.0, + "q1_ns": 88654191.0, + "q3_ns": 100059040.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25976832, + "min_bytes": 25976832, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25976832.0, + "q3_bytes": 25976832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 100059040, + 91609229, + 95551320, + 119081912, + 125854221, + 123062163, + 85938385, + 89450350, + 88254638, + 96490012, + 95539992, + 93955159, + 94753154, + 88654191, + 85935951 + ], + "raw_peak_rss_bytes": [ + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 86737950, + "min_ns": 84581122, + "mad_ns": 1926608, + "iqr_ns": 4683629.0, + "q1_ns": 84998243.0, + "q3_ns": 89681872.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25976832, + "min_bytes": 25976832, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25976832.0, + "q3_bytes": 25976832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 86737950, + 90648455, + 86645438, + 85914642, + 88101093, + 84628557, + 91777829, + 93238975, + 89681872, + 84811342, + 85823190, + 84998243, + 88744105, + 84581122, + 87272758 + ], + "raw_peak_rss_bytes": [ + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2546343204, + "min_ns": 2378484042, + "mad_ns": 52471301, + "iqr_ns": 141552129.0, + "q1_ns": 2510697920.0, + "q3_ns": 2652250049.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213053440, + "min_bytes": 203632640, + "mad_bytes": 901120, + "iqr_bytes": 9424896.0, + "q1_bytes": 204242944.0, + "q3_bytes": 213667840.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2478178581, + 2510697920, + 2584943245, + 2636368798, + 2739139681, + 2652250049, + 2676613263, + 2545646084, + 2597881508, + 2798445061, + 2544637594, + 2378484042, + 2544989008, + 2546343204, + 2493871903 + ], + "raw_peak_rss_bytes": [ + 213573632, + 204263424, + 213954560, + 203792384, + 213667840, + 204242944, + 214347776, + 212807680, + 203632640, + 213303296, + 213098496, + 204333056, + 213827584, + 213053440, + 203661312 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 83415181, + "min_ns": 80841819, + "mad_ns": 1473648, + "iqr_ns": 3206816.0, + "q1_ns": 81941533.0, + "q3_ns": 85148349.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25976832, + "min_bytes": 25976832, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25976832.0, + "q3_bytes": 25976832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84225678, + 89855754, + 81892508, + 86065579, + 83415181, + 85215606, + 84032407, + 83187057, + 82520089, + 82125830, + 81274610, + 81941533, + 80841819, + 85148349, + 83603893 + ], + "raw_peak_rss_bytes": [ + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2526517009, + "min_ns": 2357810295, + "mad_ns": 90060925, + "iqr_ns": 201993305.0, + "q1_ns": 2414584629.0, + "q3_ns": 2616577934.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 212811776, + "min_bytes": 203485184, + "mad_bytes": 1417216, + "iqr_bytes": 10149888.0, + "q1_bytes": 203866112.0, + "q3_bytes": 214016000.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2536871574, + 2414584629, + 2526517009, + 2533388155, + 2359733394, + 2447599094, + 2357810295, + 2665604096, + 2657105929, + 2812480563, + 2543295339, + 2409739199, + 2440489797, + 2616577934, + 2519650700 + ], + "raw_peak_rss_bytes": [ + 214020096, + 212811776, + 203988992, + 213991424, + 208637952, + 214016000, + 203698176, + 214364160, + 203616256, + 214228992, + 212361216, + 203866112, + 213360640, + 212836352, + 203485184 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2120280, + "min_ns": 1930715, + "mad_ns": 66371, + "iqr_ns": 146176.0, + "q1_ns": 2039679.0, + "q3_ns": 2185855.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25980928, + "min_bytes": 25980928, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25980928.0, + "q3_bytes": 25980928.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2079323, + 2149738, + 2199580, + 2120280, + 2089409, + 1930715, + 2354852, + 2167534, + 2039679, + 2312763, + 2053909, + 1973513, + 2185855, + 1980326, + 2127055 + ], + "raw_peak_rss_bytes": [ + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1581679, + "min_ns": 1481815, + "mad_ns": 62197, + "iqr_ns": 123760.0, + "q1_ns": 1546039.0, + "q3_ns": 1669799.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25989120, + "min_bytes": 25989120, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25989120.0, + "q3_bytes": 25989120.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1557668, + 1631224, + 1561597, + 1481815, + 1504937, + 1581679, + 3999005, + 1672919, + 1888834, + 1658939, + 1546039, + 1519482, + 1669799, + 1571836, + 1631731 + ], + "raw_peak_rss_bytes": [ + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 101027258, + "min_ns": 94370909, + "mad_ns": 3219326, + "iqr_ns": 8668568.0, + "q1_ns": 97888621.0, + "q3_ns": 106557189.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25989120, + "min_bytes": 25989120, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25989120.0, + "q3_bytes": 25989120.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 95618101, + 97807932, + 101598618, + 98008558, + 104907097, + 100342610, + 110038403, + 97888621, + 94370909, + 116662484, + 101027258, + 98402563, + 123134802, + 102066893, + 106557189 + ], + "raw_peak_rss_bytes": [ + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 4525088, + "min_ns": 4342492, + "mad_ns": 85237, + "iqr_ns": 197208.0, + "q1_ns": 4409260.0, + "q3_ns": 4606468.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25989120, + "min_bytes": 25989120, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25989120.0, + "q3_bytes": 25989120.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4614464, + 4439851, + 4409260, + 4598789, + 4606468, + 4579107, + 4525088, + 4435099, + 4561085, + 4609239, + 6102888, + 4389516, + 4471407, + 4342492, + 4394491 + ], + "raw_peak_rss_bytes": [ + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1554559, + "min_ns": 1418867, + "mad_ns": 60262, + "iqr_ns": 128762.0, + "q1_ns": 1486059.0, + "q3_ns": 1614821.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1649171, + 1522605, + 1475100, + 1567636, + 1499884, + 1626460, + 1468905, + 1418867, + 1600541, + 1538313, + 1571066, + 1614821, + 1554559, + 1486059, + 1776963 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 4904956, + "min_ns": 4496189, + "mad_ns": 246516, + "iqr_ns": 527243.0, + "q1_ns": 4624229.0, + "q3_ns": 5151472.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4823059, + 5149912, + 5151472, + 4984058, + 5964101, + 4904956, + 5522625, + 5429691, + 5057595, + 4624229, + 4496189, + 4553560, + 4693646, + 4507936, + 4698956 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2147223, + "min_ns": 1934215, + "mad_ns": 47259, + "iqr_ns": 99120.0, + "q1_ns": 2095362.0, + "q3_ns": 2194482.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26001408, + "min_bytes": 26001408, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26001408.0, + "q3_bytes": 26001408.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2147223, + 1955942, + 2133178, + 1934215, + 2095362, + 2194482, + 2292388, + 2057437, + 2193687, + 2186476, + 2121447, + 2197810, + 2206194, + 2123793, + 2171663 + ], + "raw_peak_rss_bytes": [ + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 94489264, + "min_ns": 86750489, + "mad_ns": 5815805, + "iqr_ns": 11312033.0, + "q1_ns": 91041432.0, + "q3_ns": 102353465.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26001408, + "min_bytes": 26001408, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26001408.0, + "q3_bytes": 26001408.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 87028009, + 89511383, + 102353465, + 100305069, + 102186615, + 104011735, + 92806863, + 91583611, + 86750489, + 102814226, + 94489264, + 95457302, + 91041432, + 91288768, + 108903486 + ], + "raw_peak_rss_bytes": [ + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2125019, + "min_ns": 1915794, + "mad_ns": 82188, + "iqr_ns": 272220.0, + "q1_ns": 2098166.0, + "q3_ns": 2370386.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26001408, + "min_bytes": 26001408, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26001408.0, + "q3_bytes": 26001408.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2371345, + 2463480, + 2113622, + 2151646, + 2105211, + 2039535, + 1915794, + 2391327, + 1999109, + 2098166, + 2178084, + 2119258, + 2370386, + 2125019, + 2207207 + ], + "raw_peak_rss_bytes": [ + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1616377, + "min_ns": 1487472, + "mad_ns": 53678, + "iqr_ns": 142176.0, + "q1_ns": 1527836.0, + "q3_ns": 1670012.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1661144, + 1741981, + 1677680, + 1487472, + 1595128, + 1625938, + 1670012, + 1562843, + 1626743, + 1512209, + 1527836, + 1504542, + 1562699, + 1845876, + 1616377 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2498241497, + "min_ns": 2380138832, + "mad_ns": 100133279, + "iqr_ns": 280472447.0, + "q1_ns": 2435807265.0, + "q3_ns": 2716279712.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213041152, + "min_bytes": 203489280, + "mad_bytes": 684032, + "iqr_bytes": 9334784.0, + "q1_bytes": 204099584.0, + "q3_bytes": 213434368.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2423281231, + 2487012759, + 2466696911, + 2498241497, + 2436005475, + 2380138832, + 2735578533, + 2891003561, + 2435807265, + 2398108218, + 2632066841, + 2717137104, + 2716279712, + 2653589994, + 2572018367 + ], + "raw_peak_rss_bytes": [ + 213057536, + 213417984, + 204050432, + 213839872, + 212426752, + 204210176, + 214577152, + 212357120, + 213041152, + 203894784, + 213622784, + 213139456, + 204099584, + 213434368, + 203489280 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1699301, + "min_ns": 1567712, + "mad_ns": 50313, + "iqr_ns": 105057.0, + "q1_ns": 1674107.0, + "q3_ns": 1779164.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2171360, + 1692399, + 2135332, + 1779164, + 1698106, + 1676547, + 1674107, + 2019741, + 1725031, + 1734909, + 1761806, + 1699301, + 1648988, + 1623580, + 1567712 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 98152897, + "min_ns": 93483568, + "mad_ns": 1928313, + "iqr_ns": 4226215.0, + "q1_ns": 97032623.0, + "q3_ns": 101258838.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 117432549, + 117611565, + 99952260, + 97032623, + 98196526, + 100081210, + 97138019, + 94487626, + 101258838, + 98152897, + 97720146, + 101484288, + 93483568, + 95811629, + 97086634 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 89144790, + "min_ns": 83222662, + "mad_ns": 2699518, + "iqr_ns": 5176498.0, + "q1_ns": 85474617.0, + "q3_ns": 90651115.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89886573, + 89144790, + 87961983, + 85474617, + 86226244, + 83222662, + 84644636, + 92710700, + 86445272, + 89210174, + 90651115, + 90603662, + 83478764, + 90687401, + 105556808 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 92700585, + "min_ns": 90283173, + "mad_ns": 1214114, + "iqr_ns": 4719488.0, + "q1_ns": 91970375.0, + "q3_ns": 96689863.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 90283173, + 94003470, + 90912553, + 91970375, + 92700585, + 93097265, + 92158076, + 92577708, + 96689863, + 92836170, + 91486471, + 106793857, + 97096288, + 92596015, + 96872095 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 87707101, + "min_ns": 84041824, + "mad_ns": 3089757, + "iqr_ns": 9460711.0, + "q1_ns": 85444671.0, + "q3_ns": 94905382.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 96144113, + 84218107, + 95165035, + 88146882, + 87707101, + 84617344, + 84041824, + 85444671, + 87000875, + 90921996, + 89255802, + 87416892, + 86245454, + 94905382, + 95372452 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2648639661, + "min_ns": 2479775689, + "mad_ns": 61313943, + "iqr_ns": 148717532.0, + "q1_ns": 2538585299.0, + "q3_ns": 2687302831.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213065728, + "min_bytes": 203513856, + "mad_bytes": 1134592, + "iqr_bytes": 9715712.0, + "q1_bytes": 204095488.0, + "q3_bytes": 213811200.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2575235476, + 2514263554, + 2639347370, + 2707984443, + 2479775689, + 2538585299, + 2538631546, + 2488307665, + 2668505627, + 2709953604, + 2687302831, + 2810361783, + 2655271917, + 2663110391, + 2648639661 + ], + "raw_peak_rss_bytes": [ + 213192704, + 213065728, + 204324864, + 213745664, + 204095488, + 214654976, + 213086208, + 204390400, + 214200320, + 203644928, + 213811200, + 203677696, + 213979136, + 212668416, + 203513856 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2413470139, + "min_ns": 2343093845, + "mad_ns": 41376936, + "iqr_ns": 89735424.0, + "q1_ns": 2365111651.0, + "q3_ns": 2454847075.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 212942848, + "min_bytes": 203870208, + "mad_bytes": 1228800, + "iqr_bytes": 9830400.0, + "q1_bytes": 204238848.0, + "q3_bytes": 214069248.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2407969069, + 2343093845, + 2449299770, + 2354831332, + 2454847075, + 2607742005, + 2365111651, + 2350042382, + 2377830633, + 2645886066, + 2433054644, + 2511275538, + 2424840350, + 2413470139, + 2396051868 + ], + "raw_peak_rss_bytes": [ + 212733952, + 204279808, + 214192128, + 204238848, + 213368832, + 213000192, + 204136448, + 213594112, + 204021760, + 214069248, + 203870208, + 214171648, + 212942848, + 208388096, + 214089728 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 4453278, + "min_ns": 4196826, + "mad_ns": 89186, + "iqr_ns": 186070.0, + "q1_ns": 4327322.0, + "q3_ns": 4513392.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4653633, + 4506072, + 4471546, + 4500183, + 4533646, + 4453278, + 4327322, + 4530534, + 4354724, + 4287810, + 4364092, + 4310484, + 4196826, + 4341696, + 4513392 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 4349800, + "min_ns": 4229866, + "mad_ns": 91572, + "iqr_ns": 176971.0, + "q1_ns": 4294951.0, + "q3_ns": 4471922.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4336572, + 4441372, + 4349800, + 4251291, + 5266152, + 4270290, + 4986539, + 4704215, + 4447820, + 4294951, + 4330714, + 4390786, + 4307653, + 4229866, + 4471922 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 90658159, + "min_ns": 85393538, + "mad_ns": 4295333, + "iqr_ns": 8600808.0, + "q1_ns": 88615186.0, + "q3_ns": 97215994.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89021629, + 90470530, + 95942676, + 90543778, + 86589046, + 119135104, + 88024435, + 103656435, + 107806564, + 90658159, + 85393538, + 96175616, + 88615186, + 97215994, + 94953492 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 65658065, + "min_ns": 61185732, + "mad_ns": 1757950, + "iqr_ns": 3789175.0, + "q1_ns": 63900115.0, + "q3_ns": 67689290.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 61286329, + 63900115, + 62616145, + 61185732, + 66100561, + 65360997, + 75579674, + 68213886, + 72663063, + 65658065, + 67689290, + 66470900, + 67159449, + 65643867, + 65644482 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2491185021, + "min_ns": 2369831190, + "mad_ns": 50641794, + "iqr_ns": 148342353.0, + "q1_ns": 2441670458.0, + "q3_ns": 2590012811.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 212865024, + "min_bytes": 203493376, + "mad_bytes": 651264, + "iqr_bytes": 9330688.0, + "q1_bytes": 204001280.0, + "q3_bytes": 213331968.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2635668490, + 2491185021, + 2417084555, + 2440543227, + 2441670458, + 2468884096, + 2564805247, + 2522958471, + 2539004378, + 2590012811, + 2479167355, + 2483913433, + 2782274743, + 2659067564, + 2369831190 + ], + "raw_peak_rss_bytes": [ + 212582400, + 212549632, + 203493376, + 213782528, + 212865024, + 203857920, + 214007808, + 213098496, + 208871424, + 213516288, + 213331968, + 204001280, + 213311488, + 212893696, + 203968512 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1611626, + "min_ns": 1524681, + "mad_ns": 41607, + "iqr_ns": 96415.0, + "q1_ns": 1556818.0, + "q3_ns": 1653233.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1837406, + 1786284, + 1597604, + 1556818, + 1589167, + 1611626, + 1544830, + 1570613, + 1653233, + 1653083, + 1704306, + 1529806, + 1615355, + 1648430, + 1524681 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1698744, + "min_ns": 1536846, + "mad_ns": 77248, + "iqr_ns": 195666.0, + "q1_ns": 1574435.0, + "q3_ns": 1770101.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1552618, + 1609050, + 1775992, + 1847345, + 1536846, + 1754636, + 1723338, + 1914041, + 1664201, + 1623917, + 1698744, + 1752390, + 1770101, + 1557149, + 1574435 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1618645, + "min_ns": 1508887, + "mad_ns": 57890, + "iqr_ns": 119495.0, + "q1_ns": 1542196.0, + "q3_ns": 1661691.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1661691, + 1623007, + 1652541, + 1684315, + 1618645, + 1541892, + 1606451, + 1542196, + 1525434, + 1909922, + 1864805, + 1656132, + 1560755, + 1508887, + 1598536 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 82525529, + "min_ns": 80215642, + "mad_ns": 1621772, + "iqr_ns": 3260156.0, + "q1_ns": 80887145.0, + "q3_ns": 84147301.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26017792, + "min_bytes": 26017792, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26017792.0, + "q3_bytes": 26017792.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 90137507, + 84363519, + 80399053, + 80983942, + 82596028, + 85087737, + 84147301, + 82525529, + 80905730, + 82517302, + 80887145, + 83633674, + 80418793, + 83012447, + 80215642 + ], + "raw_peak_rss_bytes": [ + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792, + 26017792 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 93457349, + "min_ns": 91828108, + "mad_ns": 577968, + "iqr_ns": 2375438.0, + "q1_ns": 92879381.0, + "q3_ns": 95254819.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26025984, + "min_bytes": 26025984, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26025984.0, + "q3_bytes": 26025984.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 97789623, + 91929494, + 91828108, + 93961856, + 93076336, + 93644072, + 99329383, + 93881029, + 93457349, + 93439715, + 93249764, + 92879381, + 95254819, + 92405379, + 98163198 + ], + "raw_peak_rss_bytes": [ + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1558576, + "min_ns": 1484228, + "mad_ns": 74035, + "iqr_ns": 162802.0, + "q1_ns": 1515904.0, + "q3_ns": 1678706.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26025984, + "min_bytes": 26025984, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26025984.0, + "q3_bytes": 26025984.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1607116, + 1641728, + 1671102, + 1515904, + 1556536, + 1538861, + 1706219, + 1713935, + 1524686, + 1678706, + 1484541, + 1806709, + 1484228, + 1558576, + 1492915 + ], + "raw_peak_rss_bytes": [ + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984, + 26025984 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "admissibility": { + "outcomes_reproduced": null, + "timings_reproduced": null, + "environment_valid": true, + "admissible": false, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/p022-263a-sizing-n15.linux.json b/docs/evidence/p022-263a-sizing-n15.linux.json new file mode 100644 index 00000000..4885efbf --- /dev/null +++ b/docs/evidence/p022-263a-sizing-n15.linux.json @@ -0,0 +1,3963 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "warmup_discards": 2, + "calibration_repetitions": 15, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 payload on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "harness_digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "harness_version": "1", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a" + }, + "gate_requirements": [ + "C1: a payload at p022-263a-d7-payload.json declaring kind='own.net/p022/d7-payload', carrying kind, schema, cells, rollups, instrument_anchor_commit, python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256, ratification", + "C1 carries a STRUCTURALLY COMPLETE preregistration: cells, rollups; each cell declares phase, workload_id, platform, regime and either bound, pass_fail_rule, inconclusive_band, repetition_ladder, comparison_statistic, rss_policy, allocation_policy (the ladder carrying initial_n, escalation_stages, transition_predicates, max_n, terminal_outcome) or an explicit not_applicable naming a reason in words; roll-ups carry workload_class, phase, overall_g3. Values are never read", + "C1 decides EVERY one of the 384 cells D7 covers — phase x workload_id x platform x regime over the frozen decisive manifest with aliases resolved — with no cell missing, unknown, or named twice", + "C1 declares instrument_anchor_commit S, and the instrument AT S hashes to the harness_digest C1 froze; S is an ancestor of C1. The CURRENT position is never required to equal S, because by #263-B it cannot be", + "C1's bindings equal what this process observes: python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256", + "C2: a detached attestation at p022-263a-d7-attestation.json declaring kind='own.net/p022/d7-attestation', carrying kind, schema, payload_path, payload_commit_sha, payload_blob_sha, payload_sha256, bindings, ratification_binding", + "C2's payload_sha256 equals the sha256 of the payload's EXACT BYTES", + "C2's payload_blob_sha equals the git blob sha of the payload at payload_commit_sha, and the payload's working-tree bytes are that blob", + "C2's own commit is a strict DESCENDANT of payload_commit_sha", + "C2's bindings and ratification_binding equal C1's", + "both objects are committed and unmodified in the working tree" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T16:04:48Z", + "measurements_taken": 600 + } + }, + "provenance": { + "tree_sha": "843d6fecfb38b2cf91f13ec179086f96705d7a88", + "tree_dirty": false, + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.10GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T16:11:00Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 14029881, + "iqr_ns": 447532.5, + "min_ns": 13609563, + "relative_iqr": 0.031898524299671535, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 14990133, + "iqr_ns": 808093.0, + "min_ns": 14467573, + "relative_iqr": 0.05390832756453862, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2101423, + "min_ns": 1976302, + "mad_ns": 65681, + "iqr_ns": 206250.0, + "q1_ns": 2035742.0, + "q3_ns": 2241992.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25853952, + "min_bytes": 25853952, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25853952.0, + "q3_bytes": 25853952.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2593672, + 2247349, + 1976302, + 2035742, + 2033636, + 2113993, + 2256991, + 2006759, + 2068680, + 2241992, + 2149363, + 2112342, + 2052279, + 2071476, + 2101423 + ], + "raw_peak_rss_bytes": [ + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952, + 25853952 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2649673878, + "min_ns": 2454618628, + "mad_ns": 58848839, + "iqr_ns": 128806631.0, + "q1_ns": 2579716086.0, + "q3_ns": 2708522717.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213053440, + "min_bytes": 203444224, + "mad_bytes": 782336, + "iqr_bytes": 9306112.0, + "q1_bytes": 204390400.0, + "q3_bytes": 213696512.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2630041596, + 2579716086, + 2707350259, + 2650209508, + 2766510634, + 2678052273, + 2772392746, + 2516580587, + 2454618628, + 2560194975, + 2708522717, + 2639168956, + 2619296817, + 2649673878, + 2802853743 + ], + "raw_peak_rss_bytes": [ + 213123072, + 203960320, + 213475328, + 208363520, + 213696512, + 212852736, + 213147648, + 213053440, + 203444224, + 213835776, + 204390400, + 214040576, + 213028864, + 203833344, + 213946368 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 76492770, + "min_ns": 72387712, + "mad_ns": 3563312, + "iqr_ns": 6850894.0, + "q1_ns": 74365808.0, + "q3_ns": 81216702.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 82610178, + 88348113, + 81216702, + 85326359, + 80056082, + 79680450, + 75174110, + 74365808, + 72599011, + 75720150, + 72387712, + 76492770, + 73681474, + 75162988, + 80476761 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 89453393, + "min_ns": 83997687, + "mad_ns": 3347070, + "iqr_ns": 10169839.0, + "q1_ns": 86235527.0, + "q3_ns": 96405366.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25968640, + "min_bytes": 25968640, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25968640.0, + "q3_bytes": 25968640.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89300997, + 88927609, + 92211701, + 96405366, + 102760726, + 85835052, + 86106323, + 95756558, + 83997687, + 87174048, + 101078269, + 101340820, + 90244125, + 86235527, + 89453393 + ], + "raw_peak_rss_bytes": [ + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640, + 25968640 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2467615244, + "min_ns": 2288760206, + "mad_ns": 93896887, + "iqr_ns": 246824696.0, + "q1_ns": 2395547671.0, + "q3_ns": 2642372367.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 212643840, + "min_bytes": 203649024, + "mad_bytes": 1183744, + "iqr_bytes": 9752576.0, + "q1_bytes": 204066816.0, + "q3_bytes": 213819392.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2642372367, + 2814766229, + 2813228519, + 2705551114, + 2538306063, + 2373562156, + 2445174941, + 2395547671, + 2288760206, + 2497817517, + 2561512131, + 2296836020, + 2467615244, + 2403669177, + 2435135117 + ], + "raw_peak_rss_bytes": [ + 214224896, + 212578304, + 212627456, + 203649024, + 213827584, + 208371712, + 213819392, + 212643840, + 204066816, + 213762048, + 213340160, + 203726848, + 214650880, + 212959232, + 203759616 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 88399259, + "min_ns": 84389294, + "mad_ns": 1718792, + "iqr_ns": 4253583.0, + "q1_ns": 86680467.0, + "q3_ns": 90934050.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25976832, + "min_bytes": 25976832, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25976832.0, + "q3_bytes": 25976832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 88355568, + 86680467, + 88399259, + 88567580, + 104538516, + 88499646, + 87127628, + 90934050, + 88560190, + 91789912, + 94300677, + 84389294, + 85519789, + 85209854, + 87906069 + ], + "raw_peak_rss_bytes": [ + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832, + 25976832 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 89800132, + "min_ns": 83792948, + "mad_ns": 2954839, + "iqr_ns": 5416036.0, + "q1_ns": 86283452.0, + "q3_ns": 91699488.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25980928, + "min_bytes": 25980928, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25980928.0, + "q3_bytes": 25980928.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 83792948, + 85227646, + 85738322, + 86283452, + 90793209, + 122454580, + 90571741, + 95726680, + 88968729, + 88710158, + 86845293, + 91699488, + 92788597, + 89800132, + 90444009 + ], + "raw_peak_rss_bytes": [ + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 85838572, + "min_ns": 82380614, + "mad_ns": 1498709, + "iqr_ns": 11859996.0, + "q1_ns": 84540401.0, + "q3_ns": 96400397.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25980928, + "min_bytes": 25980928, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25980928.0, + "q3_bytes": 25980928.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 96820180, + 100394716, + 85570947, + 87024076, + 96400397, + 84540401, + 92463673, + 84339863, + 85060756, + 86213209, + 112258127, + 84625718, + 83250422, + 82380614, + 85838572 + ], + "raw_peak_rss_bytes": [ + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2554570683, + "min_ns": 2467410609, + "mad_ns": 38232452, + "iqr_ns": 90253065.0, + "q1_ns": 2516338231.0, + "q3_ns": 2606591296.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213151744, + "min_bytes": 203685888, + "mad_bytes": 1208320, + "iqr_bytes": 10158080.0, + "q1_bytes": 204038144.0, + "q3_bytes": 214196224.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2579069883, + 2543569468, + 2614838644, + 2710488376, + 2863458341, + 2467410609, + 2548910040, + 2482793204, + 2554570683, + 2606591296, + 2516338231, + 2511923930, + 2589370722, + 2517876030, + 2573488345 + ], + "raw_peak_rss_bytes": [ + 213721088, + 203685888, + 214360064, + 204242944, + 214487040, + 204038144, + 214249472, + 203862016, + 214196224, + 204025856, + 213352448, + 213151744, + 212684800, + 204558336, + 213987328 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 87145229, + "min_ns": 83875452, + "mad_ns": 2546741, + "iqr_ns": 5409580.0, + "q1_ns": 85441264.0, + "q3_ns": 90850844.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25980928, + "min_bytes": 25980928, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25980928.0, + "q3_bytes": 25980928.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 91049683, + 90364236, + 87757891, + 85772787, + 94721389, + 92809422, + 85759590, + 89232281, + 85441264, + 83875452, + 84228400, + 90850844, + 84598488, + 87145229, + 86002378 + ], + "raw_peak_rss_bytes": [ + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928, + 25980928 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2489450495, + "min_ns": 2372663693, + "mad_ns": 48340499, + "iqr_ns": 114767600.0, + "q1_ns": 2441109996.0, + "q3_ns": 2555877596.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213266432, + "min_bytes": 203534336, + "mad_bytes": 856064, + "iqr_bytes": 9703424.0, + "q1_bytes": 204075008.0, + "q3_bytes": 213778432.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2489450495, + 2398486352, + 2450517129, + 2491015371, + 2607918135, + 2603507844, + 2482998137, + 2414034174, + 2441109996, + 2650737970, + 2530321833, + 2372663693, + 2555877596, + 2497266145, + 2487852310 + ], + "raw_peak_rss_bytes": [ + 212480000, + 204075008, + 213778432, + 213331968, + 203534336, + 214122496, + 203964416, + 213475328, + 204218368, + 214421504, + 213311488, + 203923456, + 213266432, + 208052224, + 214069248 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2040687, + "min_ns": 1776582, + "mad_ns": 84287, + "iqr_ns": 216723.0, + "q1_ns": 1907204.0, + "q3_ns": 2123927.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25985024, + "min_bytes": 25985024, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25985024.0, + "q3_bytes": 25985024.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2102059, + 1990305, + 2194220, + 2149688, + 2078067, + 2040687, + 2123927, + 2022675, + 2112543, + 1907204, + 2523847, + 1956400, + 1776582, + 1900554, + 1858253 + ], + "raw_peak_rss_bytes": [ + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1471558, + "min_ns": 1415985, + "mad_ns": 55573, + "iqr_ns": 109257.0, + "q1_ns": 1452643.0, + "q3_ns": 1561900.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25985024, + "min_bytes": 25985024, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25985024.0, + "q3_bytes": 25985024.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1441610, + 1467269, + 1550017, + 1658888, + 1572160, + 1561900, + 1452643, + 1471558, + 1534164, + 1425046, + 1453038, + 1713943, + 1415985, + 1527215, + 1465874 + ], + "raw_peak_rss_bytes": [ + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024, + 25985024 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 94506837, + "min_ns": 91678715, + "mad_ns": 1050344, + "iqr_ns": 2102536.0, + "q1_ns": 93454645.0, + "q3_ns": 95557181.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25989120, + "min_bytes": 25989120, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25989120.0, + "q3_bytes": 25989120.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 93883540, + 95557181, + 101243812, + 98057248, + 99674589, + 94625021, + 94506837, + 94284729, + 94858722, + 93000585, + 92684764, + 93454645, + 95148806, + 93545421, + 91678715 + ], + "raw_peak_rss_bytes": [ + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 4643795, + "min_ns": 4273010, + "mad_ns": 149044, + "iqr_ns": 393710.0, + "q1_ns": 4395317.0, + "q3_ns": 4789027.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25989120, + "min_bytes": 25989120, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25989120.0, + "q3_bytes": 25989120.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4643795, + 4395317, + 4494751, + 4348890, + 4680065, + 4375843, + 4789027, + 4273010, + 4885558, + 4691521, + 4692785, + 4911361, + 4495732, + 4563795, + 5049742 + ], + "raw_peak_rss_bytes": [ + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120, + 25989120 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1527991, + "min_ns": 1471982, + "mad_ns": 51045, + "iqr_ns": 143904.0, + "q1_ns": 1499169.0, + "q3_ns": 1643073.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1497437, + 1579036, + 1661393, + 1643073, + 1597431, + 1621760, + 1527991, + 1471982, + 1502557, + 1517497, + 1509347, + 1499169, + 1477739, + 1756771, + 1666237 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 4604571, + "min_ns": 4347890, + "mad_ns": 143809, + "iqr_ns": 260095.0, + "q1_ns": 4411936.0, + "q3_ns": 4672031.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5735225, + 4628814, + 4634316, + 4490424, + 4672031, + 4691403, + 4623875, + 4422195, + 4347890, + 4460762, + 4402010, + 4387090, + 4827362, + 4411936, + 4604571 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2048070, + "min_ns": 1893302, + "mad_ns": 96724, + "iqr_ns": 212008.0, + "q1_ns": 1932786.0, + "q3_ns": 2144794.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2040017, + 2103649, + 2048070, + 1893302, + 2064406, + 2144794, + 2082641, + 2152957, + 1996413, + 1991620, + 2155368, + 1904844, + 2197974, + 1919764, + 1932786 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 84301632, + "min_ns": 79676573, + "mad_ns": 1989432, + "iqr_ns": 3570594.0, + "q1_ns": 82776276.0, + "q3_ns": 86346870.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 82971581, + 82776276, + 81339356, + 90317006, + 84134269, + 89690377, + 86291064, + 86769945, + 85956906, + 86346870, + 81985512, + 79676573, + 86206248, + 84301632, + 84264128 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2067745, + "min_ns": 1799380, + "mad_ns": 67894, + "iqr_ns": 183813.0, + "q1_ns": 1999851.0, + "q3_ns": 2183664.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2226416, + 2067745, + 2107930, + 1886479, + 2001307, + 2183664, + 1799380, + 2079361, + 1932236, + 1999851, + 2206150, + 2090765, + 2002591, + 2346233, + 2047771 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1574480, + "min_ns": 1457831, + "mad_ns": 39897, + "iqr_ns": 107829.0, + "q1_ns": 1544509.0, + "q3_ns": 1652338.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1515240, + 1549869, + 1632557, + 2819952, + 1568198, + 1580593, + 1544509, + 1719244, + 1753575, + 1573684, + 1652338, + 1534583, + 1457831, + 1579788, + 1574480 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2518102333, + "min_ns": 2428424685, + "mad_ns": 47588390, + "iqr_ns": 106153847.0, + "q1_ns": 2459536876.0, + "q3_ns": 2565690723.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213286912, + "min_bytes": 203517952, + "mad_bytes": 614400, + "iqr_bytes": 9834496.0, + "q1_bytes": 203935744.0, + "q3_bytes": 213770240.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2645129642, + 2573850919, + 2636161247, + 2457259919, + 2473451033, + 2428424685, + 2454464751, + 2533844814, + 2534944805, + 2518102333, + 2537357475, + 2508780342, + 2459536876, + 2484627745, + 2565690723 + ], + "raw_peak_rss_bytes": [ + 213286912, + 212852736, + 203915264, + 213770240, + 203935744, + 214118400, + 212885504, + 204242944, + 214315008, + 213450752, + 203649024, + 213417984, + 213368832, + 203517952, + 213901312 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1756682, + "min_ns": 1544060, + "mad_ns": 139027, + "iqr_ns": 454582.0, + "q1_ns": 1654595.0, + "q3_ns": 2109177.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1766859, + 2083351, + 1591745, + 1617655, + 1544060, + 2109177, + 2177671, + 1675000, + 1756682, + 1841403, + 2166095, + 1654595, + 2149487, + 1722906, + 1726469 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 98614758, + "min_ns": 92720430, + "mad_ns": 2568459, + "iqr_ns": 6899734.0, + "q1_ns": 93598907.0, + "q3_ns": 100498641.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 137245690, + 97755935, + 93598907, + 93686686, + 96552746, + 99557698, + 102838739, + 99910541, + 98614758, + 92720430, + 93277932, + 93292234, + 101183217, + 100498641, + 98704970 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 84332124, + "min_ns": 81932492, + "mad_ns": 1663537, + "iqr_ns": 5417817.0, + "q1_ns": 82734830.0, + "q3_ns": 88152647.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 88152647, + 82734830, + 82818779, + 85519123, + 82653772, + 81932492, + 83805648, + 91772200, + 90921802, + 85371322, + 92706121, + 87636810, + 84163265, + 84332124, + 82668587 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 94405363, + "min_ns": 91022128, + "mad_ns": 2026191, + "iqr_ns": 3735395.0, + "q1_ns": 93099460.0, + "q3_ns": 96834855.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 91977149, + 91022128, + 93459608, + 96961682, + 93099460, + 94405363, + 96834855, + 97015310, + 93141841, + 98478886, + 92155008, + 95149770, + 93474839, + 96431554, + 94430817 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 86749942, + "min_ns": 83840190, + "mad_ns": 2141024, + "iqr_ns": 5026658.0, + "q1_ns": 84608918.0, + "q3_ns": 89635576.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25993216, + "min_bytes": 25993216, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25993216.0, + "q3_bytes": 25993216.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84712248, + 83981222, + 84141884, + 85024393, + 88358506, + 95855305, + 104192349, + 90533959, + 89635576, + 87398014, + 87064320, + 86693722, + 86749942, + 83840190, + 84608918 + ], + "raw_peak_rss_bytes": [ + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216, + 25993216 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 2565477939, + "min_ns": 2477768256, + "mad_ns": 64048106, + "iqr_ns": 134891163.0, + "q1_ns": 2501429833.0, + "q3_ns": 2636320996.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 212881408, + "min_bytes": 203751424, + "mad_bytes": 872448, + "iqr_bytes": 9461760.0, + "q1_bytes": 204292096.0, + "q3_bytes": 213753856.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2535596784, + 2477768256, + 2629184921, + 2496706928, + 2498602701, + 2905247911, + 2522844135, + 2530843181, + 2501429833, + 2623155483, + 2644941089, + 2636320996, + 2652431882, + 2565477939, + 2628315377 + ], + "raw_peak_rss_bytes": [ + 213553152, + 203751424, + 214032384, + 212754432, + 204177408, + 213753856, + 213327872, + 212881408, + 204292096, + 214065152, + 212885504, + 203759616, + 214282240, + 212492288, + 212602880 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2481433692, + "min_ns": 2395271590, + "mad_ns": 60873558, + "iqr_ns": 141557975.0, + "q1_ns": 2429947323.0, + "q3_ns": 2571505298.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213471232, + "min_bytes": 203849728, + "mad_bytes": 466944, + "iqr_bytes": 5517312.0, + "q1_bytes": 208211968.0, + "q3_bytes": 213729280.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2571505298, + 2515880118, + 2399519413, + 2429947323, + 2498099992, + 2651044293, + 2615481264, + 2420560134, + 2463322000, + 2464282716, + 2558759852, + 2479735979, + 2574049484, + 2395271590, + 2481433692 + ], + "raw_peak_rss_bytes": [ + 213528576, + 208211968, + 213864448, + 213471232, + 212742144, + 203866112, + 213475328, + 213729280, + 203849728, + 214147072, + 213004288, + 213827584, + 204025856, + 213647360, + 212566016 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 4547888, + "min_ns": 4358126, + "mad_ns": 93158, + "iqr_ns": 206181.0, + "q1_ns": 4434865.0, + "q3_ns": 4641046.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25997312, + "min_bytes": 25997312, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25997312.0, + "q3_bytes": 25997312.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5031538, + 4677949, + 4474994, + 4641046, + 4547888, + 4632020, + 4434865, + 4409756, + 4570154, + 4418142, + 4474048, + 4945655, + 4358126, + 4578586, + 4503808 + ], + "raw_peak_rss_bytes": [ + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 4497573, + "min_ns": 4287935, + "mad_ns": 79982, + "iqr_ns": 166559.0, + "q1_ns": 4410996.0, + "q3_ns": 4577555.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 25997312, + "min_bytes": 25997312, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25997312.0, + "q3_bytes": 25997312.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4729570, + 4565359, + 4287935, + 4497573, + 4425204, + 4507353, + 4410996, + 4371694, + 4485959, + 4480518, + 4371701, + 4508358, + 4730790, + 4607856, + 4577555 + ], + "raw_peak_rss_bytes": [ + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312, + 25997312 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 86633134, + "min_ns": 84028339, + "mad_ns": 1373974, + "iqr_ns": 2620061.0, + "q1_ns": 85255183.0, + "q3_ns": 87875244.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26001408, + "min_bytes": 26001408, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26001408.0, + "q3_bytes": 26001408.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 85255183, + 86633134, + 85259160, + 97448962, + 87434661, + 85664567, + 87474744, + 87649030, + 88300906, + 84890539, + 84503180, + 84028339, + 85900740, + 87875244, + 102792722 + ], + "raw_peak_rss_bytes": [ + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 69605209, + "min_ns": 65744116, + "mad_ns": 1606334, + "iqr_ns": 4070500.0, + "q1_ns": 67998875.0, + "q3_ns": 72069375.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26001408, + "min_bytes": 26001408, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26001408.0, + "q3_bytes": 26001408.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 69628247, + 69605209, + 74818201, + 66189688, + 67277269, + 68382455, + 68912592, + 70286722, + 72195081, + 67998875, + 69025013, + 70837779, + 72069375, + 75417730, + 65744116 + ], + "raw_peak_rss_bytes": [ + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408, + 26001408 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 2504819582, + "min_ns": 2438940000, + "mad_ns": 35091490, + "iqr_ns": 120029901.0, + "q1_ns": 2477674703.0, + "q3_ns": 2597704604.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 213078016, + "min_bytes": 203538432, + "mad_bytes": 901120, + "iqr_bytes": 9461760.0, + "q1_bytes": 204517376.0, + "q3_bytes": 213979136.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2438940000, + 2494686153, + 2468323133, + 2507664217, + 2504819582, + 2597704604, + 2497191463, + 2835718896, + 2644536783, + 2477674703, + 2512530019, + 2452317396, + 2504348884, + 2611680429, + 2539911072 + ], + "raw_peak_rss_bytes": [ + 204267520, + 214175744, + 213164032, + 204517376, + 213979136, + 213020672, + 204120064, + 214073344, + 213078016, + 213352448, + 213622784, + 203538432, + 214114304, + 212393984, + 212926464 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1819100, + "min_ns": 1673466, + "mad_ns": 74702, + "iqr_ns": 221349.0, + "q1_ns": 1744398.0, + "q3_ns": 1965747.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1965747, + 1865185, + 1744398, + 1673466, + 1798134, + 1967552, + 1701946, + 2247842, + 2002071, + 1800442, + 1751725, + 1678937, + 1819100, + 1831194, + 1845310 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1754479, + "min_ns": 1668397, + "mad_ns": 47302, + "iqr_ns": 118734.0, + "q1_ns": 1707177.0, + "q3_ns": 1825911.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1668397, + 1689147, + 1691769, + 1825911, + 2000085, + 1754479, + 1999019, + 1918009, + 1800816, + 1724038, + 1772443, + 1707177, + 1738949, + 1765435, + 1724295 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 1781367, + "min_ns": 1560565, + "mad_ns": 115741, + "iqr_ns": 183547.0, + "q1_ns": 1629384.0, + "q3_ns": 1812931.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1697127, + 1781367, + 1627952, + 1629254, + 1665626, + 1560565, + 1629384, + 1781990, + 1769152, + 2097260, + 1788735, + 1812931, + 2455756, + 1787747, + 2070442 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 90663773, + "min_ns": 82257632, + "mad_ns": 4827130, + "iqr_ns": 14633831.0, + "q1_ns": 86483875.0, + "q3_ns": 101117706.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 85836643, + 86483875, + 98408849, + 93993086, + 88740083, + 84491829, + 82257632, + 90663773, + 105790618, + 104127154, + 89578994, + 101117706, + 103181809, + 93426541, + 88570042 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 15, + "median_ns": 104636907, + "min_ns": 93573942, + "mad_ns": 5062264, + "iqr_ns": 12568885.0, + "q1_ns": 96232440.0, + "q3_ns": 108801325.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 110020828, + 105196065, + 104636907, + 108801325, + 120772701, + 105965171, + 109527526, + 99937779, + 96232440, + 94037598, + 105667729, + 99574643, + 95490618, + 93573942, + 98469163 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 15, + "median_ns": 1649771, + "min_ns": 1470464, + "mad_ns": 85751, + "iqr_ns": 235909.0, + "q1_ns": 1564020.0, + "q3_ns": 1799929.0 + }, + "peak_rss": { + "n": 15, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1676925, + 1651266, + 1649771, + 1678132, + 2003560, + 2044127, + 1802714, + 1602419, + 1589022, + 1470464, + 1799929, + 1553914, + 1575983, + 1534647, + 1564020 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "reproducibility": { + "tag": "CALIBRATION_ONLY", + "earlier_run": { + "path": "p022-263a-sizing-n15-run-a.linux.json", + "sha256": "c9a79d00a5e3947c98438d69c75d706a14b571a666dc54ae64aca758d3efcf3b", + "bytes": 94189, + "tree_sha": "843d6fecfb38b2cf91f13ec179086f96705d7a88", + "tree_dirty": false, + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "harness_digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "calibration_repetitions": 15, + "warmup_discards": 2, + "candidate_sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "candidate_bytes": 1841648 + }, + "compared_cells": 40, + "tolerance_relative": 0.35, + "tolerance_source": "REPRODUCIBILITY_MAX_MEDIAN_CHANGE, a fixed policy constant. It is CHOSEN, not derived from this run; what makes it admissible is that it was chosen before the runs it judges, and it is not adjusted after seeing which of them it rejects.", + "cells_only_in_earlier": [], + "cells_only_in_later": [], + "cells_outside_tolerance": [], + "cells_whose_outcome_changed": [], + "outcomes_reproduced": true, + "timings_reproduced": true, + "reproduced": true + }, + "admissibility": { + "outcomes_reproduced": true, + "timings_reproduced": true, + "environment_valid": true, + "admissible": true, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/p022-263a-sizing-n5-run-a.linux.json b/docs/evidence/p022-263a-sizing-n5-run-a.linux.json new file mode 100644 index 00000000..7a0005db --- /dev/null +++ b/docs/evidence/p022-263a-sizing-n5-run-a.linux.json @@ -0,0 +1,3135 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "warmup_discards": 2, + "calibration_repetitions": 5, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 payload on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "harness_digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "harness_version": "1", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a" + }, + "gate_requirements": [ + "C1: a payload at p022-263a-d7-payload.json declaring kind='own.net/p022/d7-payload', carrying kind, schema, cells, rollups, instrument_anchor_commit, python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256, ratification", + "C1 carries a STRUCTURALLY COMPLETE preregistration: cells, rollups; each cell declares phase, workload_id, platform, regime and either bound, pass_fail_rule, inconclusive_band, repetition_ladder, comparison_statistic, rss_policy, allocation_policy (the ladder carrying initial_n, escalation_stages, transition_predicates, max_n, terminal_outcome) or an explicit not_applicable naming a reason in words; roll-ups carry workload_class, phase, overall_g3. Values are never read", + "C1 decides EVERY one of the 384 cells D7 covers — phase x workload_id x platform x regime over the frozen decisive manifest with aliases resolved — with no cell missing, unknown, or named twice", + "C1 declares instrument_anchor_commit S, and the instrument AT S hashes to the harness_digest C1 froze; S is an ancestor of C1. The CURRENT position is never required to equal S, because by #263-B it cannot be", + "C1's bindings equal what this process observes: python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256", + "C2: a detached attestation at p022-263a-d7-attestation.json declaring kind='own.net/p022/d7-attestation', carrying kind, schema, payload_path, payload_commit_sha, payload_blob_sha, payload_sha256, bindings, ratification_binding", + "C2's payload_sha256 equals the sha256 of the payload's EXACT BYTES", + "C2's payload_blob_sha equals the git blob sha of the payload at payload_commit_sha, and the payload's working-tree bytes are that blob", + "C2's own commit is a strict DESCENDANT of payload_commit_sha", + "C2's bindings and ratification_binding equal C1's", + "both objects are committed and unmodified in the working tree" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T15:53:01Z", + "measurements_taken": 200 + } + }, + "provenance": { + "tree_sha": "843d6fecfb38b2cf91f13ec179086f96705d7a88", + "tree_dirty": false, + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.10GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T15:56:06Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 13732471, + "iqr_ns": 329689.5, + "min_ns": 13512692, + "relative_iqr": 0.02400802448445003, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 15032982, + "iqr_ns": 1093090.0, + "min_ns": 14443388, + "relative_iqr": 0.07271278579326444, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2072275, + "min_ns": 1978902, + "mad_ns": 71128, + "iqr_ns": 382171.0, + "q1_ns": 1990024.5, + "q3_ns": 2372195.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25673728, + "min_bytes": 25673728, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25673728.0, + "q3_bytes": 25673728.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2658372, + 2086019, + 2072275, + 2001147, + 1978902 + ], + "raw_peak_rss_bytes": [ + 25673728, + 25673728, + 25673728, + 25673728, + 25673728 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2770438555, + "min_ns": 2612301569, + "mad_ns": 30424665, + "iqr_ns": 344546003.0, + "q1_ns": 2676157729.5, + "q3_ns": 3020703732.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213430272, + "min_bytes": 203616256, + "mad_bytes": 643072, + "iqr_bytes": 10223616.0, + "q1_bytes": 203771904.0, + "q3_bytes": 213995520.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2740013890, + 3250276198, + 2770438555, + 2791131267, + 2612301569 + ], + "raw_peak_rss_bytes": [ + 203616256, + 213430272, + 214073344, + 203927552, + 213917696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 65206919, + "min_ns": 62637363, + "mad_ns": 2569556, + "iqr_ns": 9251615.0, + "q1_ns": 63349185.5, + "q3_ns": 72600800.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25923584, + "min_bytes": 25923584, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25923584.0, + "q3_bytes": 25923584.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 62637363, + 65206919, + 71593605, + 64061008, + 73607996 + ], + "raw_peak_rss_bytes": [ + 25923584, + 25923584, + 25923584, + 25923584, + 25923584 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 91441015, + "min_ns": 87345295, + "mad_ns": 1956109, + "iqr_ns": 6892547.0, + "q1_ns": 88415100.5, + "q3_ns": 95307647.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25927680, + "min_bytes": 25927680, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25927680.0, + "q3_bytes": 25927680.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89484906, + 97800544, + 91441015, + 87345295, + 92814751 + ], + "raw_peak_rss_bytes": [ + 25927680, + 25927680, + 25927680, + 25927680, + 25927680 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2446612400, + "min_ns": 2322939509, + "mad_ns": 42889592, + "iqr_ns": 236520037.5, + "q1_ns": 2363331158.5, + "q3_ns": 2599851196.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213278720, + "min_bytes": 203481088, + "mad_bytes": 983040, + "iqr_bytes": 10532864.0, + "q1_bytes": 203558912.0, + "q3_bytes": 214091776.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2446612400, + 2322939509, + 2455645661, + 2744056731, + 2403722808 + ], + "raw_peak_rss_bytes": [ + 213278720, + 203481088, + 213921792, + 203636736, + 214261760 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 83058960, + "min_ns": 80660866, + "mad_ns": 760593, + "iqr_ns": 2446968.0, + "q1_ns": 80999366.0, + "q3_ns": 83446334.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25927680, + "min_bytes": 25927680, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25927680.0, + "q3_bytes": 25927680.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 83058960, + 83073115, + 81337866, + 80660866, + 83819553 + ], + "raw_peak_rss_bytes": [ + 25927680, + 25927680, + 25927680, + 25927680, + 25927680 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 87263191, + "min_ns": 84549288, + "mad_ns": 1494959, + "iqr_ns": 3629474.5, + "q1_ns": 84881424.5, + "q3_ns": 88510899.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25931776, + "min_bytes": 25931776, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25931776.0, + "q3_bytes": 25931776.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84549288, + 88758150, + 85213561, + 88263648, + 87263191 + ], + "raw_peak_rss_bytes": [ + 25931776, + 25931776, + 25931776, + 25931776, + 25931776 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 84749548, + "min_ns": 84307794, + "mad_ns": 441754, + "iqr_ns": 1414128.0, + "q1_ns": 84312689.0, + "q3_ns": 85726817.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25931776, + "min_bytes": 25931776, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25931776.0, + "q3_bytes": 25931776.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84749548, + 84307794, + 84317584, + 85825047, + 85628587 + ], + "raw_peak_rss_bytes": [ + 25931776, + 25931776, + 25931776, + 25931776, + 25931776 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2502906656, + "min_ns": 2455736961, + "mad_ns": 44011759, + "iqr_ns": 129551736.0, + "q1_ns": 2457315929.0, + "q3_ns": 2586867665.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 212762624, + "min_bytes": 203640832, + "mad_bytes": 1130496, + "iqr_bytes": 9881600.0, + "q1_bytes": 203915264.0, + "q3_bytes": 213796864.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2502906656, + 2638839222, + 2455736961, + 2534896108, + 2458894897 + ], + "raw_peak_rss_bytes": [ + 213700608, + 212762624, + 204189696, + 213893120, + 203640832 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 83575130, + "min_ns": 81155165, + "mad_ns": 2114991, + "iqr_ns": 4109403.5, + "q1_ns": 81307652.0, + "q3_ns": 85417055.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25931776, + "min_bytes": 25931776, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25931776.0, + "q3_bytes": 25931776.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 81460139, + 81155165, + 83575130, + 83582973, + 87251138 + ], + "raw_peak_rss_bytes": [ + 25931776, + 25931776, + 25931776, + 25931776, + 25931776 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2706949240, + "min_ns": 2461855103, + "mad_ns": 73079043, + "iqr_ns": 252917691.5, + "q1_ns": 2515556999.0, + "q3_ns": 2768474690.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213159936, + "min_bytes": 203935744, + "mad_bytes": 712704, + "iqr_bytes": 9701376.0, + "q1_bytes": 204085248.0, + "q3_bytes": 213786624.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2706949240, + 2569258895, + 2780028283, + 2756921098, + 2461855103 + ], + "raw_peak_rss_bytes": [ + 213872640, + 203935744, + 213700608, + 213159936, + 204234752 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2050224, + "min_ns": 2019635, + "mad_ns": 7701, + "iqr_ns": 91922.0, + "q1_ns": 2031079.0, + "q3_ns": 2123001.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25935872, + "min_bytes": 25935872, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25935872.0, + "q3_bytes": 25935872.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2191339, + 2042523, + 2050224, + 2019635, + 2054663 + ], + "raw_peak_rss_bytes": [ + 25935872, + 25935872, + 25935872, + 25935872, + 25935872 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1608809, + "min_ns": 1522881, + "mad_ns": 14477, + "iqr_ns": 86185.5, + "q1_ns": 1533941.5, + "q3_ns": 1620127.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25935872, + "min_bytes": 25935872, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25935872.0, + "q3_bytes": 25935872.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1545002, + 1608809, + 1522881, + 1616968, + 1623286 + ], + "raw_peak_rss_bytes": [ + 25935872, + 25935872, + 25935872, + 25935872, + 25935872 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 93584801, + "min_ns": 91275626, + "mad_ns": 2259036, + "iqr_ns": 5499838.0, + "q1_ns": 91417202.5, + "q3_ns": 96917040.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25935872, + "min_bytes": 25935872, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25935872.0, + "q3_bytes": 25935872.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 91275626, + 95843837, + 93584801, + 97990244, + 91558779 + ], + "raw_peak_rss_bytes": [ + 25935872, + 25935872, + 25935872, + 25935872, + 25935872 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 4541533, + "min_ns": 4300022, + "mad_ns": 180264, + "iqr_ns": 346038.5, + "q1_ns": 4317373.5, + "q3_ns": 4663412.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25944064, + "min_bytes": 25944064, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25944064.0, + "q3_bytes": 25944064.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4721797, + 4605027, + 4300022, + 4334725, + 4541533 + ], + "raw_peak_rss_bytes": [ + 25944064, + 25944064, + 25944064, + 25944064, + 25944064 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1491783, + "min_ns": 1392619, + "mad_ns": 55823, + "iqr_ns": 137619.0, + "q1_ns": 1414289.5, + "q3_ns": 1551908.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25948160, + "min_bytes": 25948160, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25948160.0, + "q3_bytes": 25948160.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1392619, + 1565264, + 1435960, + 1538553, + 1491783 + ], + "raw_peak_rss_bytes": [ + 25948160, + 25948160, + 25948160, + 25948160, + 25948160 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 4435767, + "min_ns": 4383791, + "mad_ns": 51976, + "iqr_ns": 188733.5, + "q1_ns": 4405687.5, + "q3_ns": 4594421.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25948160, + "min_bytes": 25948160, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25948160.0, + "q3_bytes": 25948160.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4435767, + 4690231, + 4498611, + 4427584, + 4383791 + ], + "raw_peak_rss_bytes": [ + 25948160, + 25948160, + 25948160, + 25948160, + 25948160 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1922016, + "min_ns": 1833045, + "mad_ns": 64278, + "iqr_ns": 196936.0, + "q1_ns": 1847750.0, + "q3_ns": 2044686.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1986294, + 1862455, + 2103078, + 1833045, + 1922016 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 83347720, + "min_ns": 82201899, + "mad_ns": 785473, + "iqr_ns": 2011154.0, + "q1_ns": 82576808.5, + "q3_ns": 84587962.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 85042732, + 84133193, + 82951718, + 83347720, + 82201899 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2005185, + "min_ns": 1921618, + "mad_ns": 83567, + "iqr_ns": 302226.5, + "q1_ns": 1946386.5, + "q3_ns": 2248613.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2333443, + 2005185, + 2163783, + 1921618, + 1971155 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1599598, + "min_ns": 1521300, + "mad_ns": 54839, + "iqr_ns": 119713.5, + "q1_ns": 1540763.5, + "q3_ns": 1660477.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1560227, + 1654437, + 1599598, + 1666517, + 1521300 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2501897088, + "min_ns": 2420195076, + "mad_ns": 38417998, + "iqr_ns": 99754847.0, + "q1_ns": 2443728936.0, + "q3_ns": 2543483783.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 214028288, + "min_bytes": 203587584, + "mad_bytes": 118784, + "iqr_bytes": 10500096.0, + "q1_bytes": 203636736.0, + "q3_bytes": 214136832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2501897088, + 2420195076, + 2540315086, + 2467262796, + 2546652480 + ], + "raw_peak_rss_bytes": [ + 214028288, + 203685888, + 214147072, + 203587584, + 214126592 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1715452, + "min_ns": 1616957, + "mad_ns": 98495, + "iqr_ns": 328742.0, + "q1_ns": 1633013.5, + "q3_ns": 1961755.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1925274, + 1998237, + 1616957, + 1649070, + 1715452 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 97152070, + "min_ns": 94502753, + "mad_ns": 2649317, + "iqr_ns": 21801420.5, + "q1_ns": 95254140.5, + "q3_ns": 117055561.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 107993759, + 96005528, + 94502753, + 97152070, + 126117363 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 85315394, + "min_ns": 82350512, + "mad_ns": 1246655, + "iqr_ns": 6213595.5, + "q1_ns": 83499374.0, + "q3_ns": 89712969.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 82350512, + 86562049, + 84648236, + 92863890, + 85315394 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 95773884, + "min_ns": 93263503, + "mad_ns": 1005210, + "iqr_ns": 3030804.0, + "q1_ns": 94399481.0, + "q3_ns": 97430285.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 95773884, + 93263503, + 98081476, + 96779094, + 95535459 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 90323368, + "min_ns": 86669665, + "mad_ns": 1606691, + "iqr_ns": 6325268.0, + "q1_ns": 88152551.0, + "q3_ns": 94477819.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26034176, + "min_bytes": 26034176, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26034176.0, + "q3_bytes": 26034176.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89635437, + 90323368, + 86669665, + 91930059, + 97025579 + ], + "raw_peak_rss_bytes": [ + 26034176, + 26034176, + 26034176, + 26034176, + 26034176 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2490850183, + "min_ns": 2407262685, + "mad_ns": 81184627, + "iqr_ns": 159480267.0, + "q1_ns": 2428497492.5, + "q3_ns": 2587977759.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213307392, + "min_bytes": 203694080, + "mad_bytes": 569344, + "iqr_bytes": 9955328.0, + "q1_bytes": 203896832.0, + "q3_bytes": 213852160.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2490850183, + 2449732300, + 2603920709, + 2572034810, + 2407262685 + ], + "raw_peak_rss_bytes": [ + 213827584, + 203694080, + 213876736, + 213307392, + 204099584 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2411261760, + "min_ns": 2308189440, + "mad_ns": 14199473, + "iqr_ns": 86179386.0, + "q1_ns": 2353481112.5, + "q3_ns": 2439660498.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213303296, + "min_bytes": 203751424, + "mad_bytes": 1208320, + "iqr_bytes": 10346496.0, + "q1_bytes": 203804672.0, + "q3_bytes": 214151168.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2453859764, + 2398772785, + 2425461233, + 2308189440, + 2411261760 + ], + "raw_peak_rss_bytes": [ + 213303296, + 203751424, + 214511616, + 203857920, + 213790720 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 4864313, + "min_ns": 4542440, + "mad_ns": 88020, + "iqr_ns": 825723.0, + "q1_ns": 4668021.5, + "q3_ns": 5493744.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26038272, + "min_bytes": 26038272, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26038272.0, + "q3_bytes": 26038272.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4793603, + 4864313, + 4952333, + 4542440, + 6035156 + ], + "raw_peak_rss_bytes": [ + 26038272, + 26038272, + 26038272, + 26038272, + 26038272 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 6385273, + "min_ns": 6197784, + "mad_ns": 76708, + "iqr_ns": 243295.5, + "q1_ns": 6258150.5, + "q3_ns": 6501446.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26038272, + "min_bytes": 26038272, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26038272.0, + "q3_bytes": 26038272.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 6197784, + 6540911, + 6318517, + 6385273, + 6461981 + ], + "raw_peak_rss_bytes": [ + 26038272, + 26038272, + 26038272, + 26038272, + 26038272 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 84516755, + "min_ns": 81000982, + "mad_ns": 3515773, + "iqr_ns": 7414361.0, + "q1_ns": 81084881.0, + "q3_ns": 88499242.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26038272, + "min_bytes": 26038272, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26038272.0, + "q3_bytes": 26038272.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 88105829, + 81168780, + 88892655, + 81000982, + 84516755 + ], + "raw_peak_rss_bytes": [ + 26038272, + 26038272, + 26038272, + 26038272, + 26038272 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 63981254, + "min_ns": 61626624, + "mad_ns": 1616068, + "iqr_ns": 3149566.5, + "q1_ns": 62763643.5, + "q3_ns": 65913210.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26038272, + "min_bytes": 26038272, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26038272.0, + "q3_bytes": 26038272.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 63981254, + 65597322, + 61626624, + 63900663, + 66229098 + ], + "raw_peak_rss_bytes": [ + 26038272, + 26038272, + 26038272, + 26038272, + 26038272 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2520669163, + "min_ns": 2346966970, + "mad_ns": 19403647, + "iqr_ns": 124403944.5, + "q1_ns": 2432047749.0, + "q3_ns": 2556451693.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 208859136, + "min_bytes": 203939840, + "mad_bytes": 4698112, + "iqr_bytes": 9408512.0, + "q1_bytes": 204050432.0, + "q3_bytes": 213458944.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2346966970, + 2540072810, + 2517128528, + 2520669163, + 2572830577 + ], + "raw_peak_rss_bytes": [ + 204161024, + 213929984, + 212987904, + 203939840, + 208859136 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1744589, + "min_ns": 1659592, + "mad_ns": 84997, + "iqr_ns": 200776.0, + "q1_ns": 1662155.5, + "q3_ns": 1862931.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26038272, + "min_bytes": 26038272, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26038272.0, + "q3_bytes": 26038272.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1866254, + 1859609, + 1744589, + 1664719, + 1659592 + ], + "raw_peak_rss_bytes": [ + 26038272, + 26038272, + 26038272, + 26038272, + 26038272 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1709591, + "min_ns": 1667558, + "mad_ns": 42033, + "iqr_ns": 97112.0, + "q1_ns": 1683439.0, + "q3_ns": 1780551.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26042368, + "min_bytes": 26042368, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26042368.0, + "q3_bytes": 26042368.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1699320, + 1804078, + 1667558, + 1757024, + 1709591 + ], + "raw_peak_rss_bytes": [ + 26042368, + 26042368, + 26042368, + 26042368, + 26042368 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1679324, + "min_ns": 1484308, + "mad_ns": 57579, + "iqr_ns": 209541.0, + "q1_ns": 1572585.0, + "q3_ns": 1782126.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26042368, + "min_bytes": 26042368, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26042368.0, + "q3_bytes": 26042368.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1827349, + 1736903, + 1484308, + 1679324, + 1660862 + ], + "raw_peak_rss_bytes": [ + 26042368, + 26042368, + 26042368, + 26042368, + 26042368 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 87944242, + "min_ns": 84594599, + "mad_ns": 3322797, + "iqr_ns": 6591198.0, + "q1_ns": 85174306.0, + "q3_ns": 91765504.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26042368, + "min_bytes": 26042368, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26042368.0, + "q3_bytes": 26042368.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84594599, + 85754013, + 87944242, + 92263969, + 91267039 + ], + "raw_peak_rss_bytes": [ + 26042368, + 26042368, + 26042368, + 26042368, + 26042368 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 96251833, + "min_ns": 94739282, + "mad_ns": 1007185, + "iqr_ns": 5213290.5, + "q1_ns": 95117006.5, + "q3_ns": 100330297.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26042368, + "min_bytes": 26042368, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26042368.0, + "q3_bytes": 26042368.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 96251833, + 97259018, + 94739282, + 95494731, + 103401576 + ], + "raw_peak_rss_bytes": [ + 26042368, + 26042368, + 26042368, + 26042368, + 26042368 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1659753, + "min_ns": 1567133, + "mad_ns": 92620, + "iqr_ns": 352752.5, + "q1_ns": 1612216.5, + "q3_ns": 1964969.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26042368, + "min_bytes": 26042368, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26042368.0, + "q3_bytes": 26042368.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1567133, + 1659753, + 1938364, + 1991574, + 1657300 + ], + "raw_peak_rss_bytes": [ + 26042368, + 26042368, + 26042368, + 26042368, + 26042368 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "admissibility": { + "outcomes_reproduced": null, + "timings_reproduced": null, + "environment_valid": true, + "admissible": false, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/p022-263a-sizing-n5.linux.json b/docs/evidence/p022-263a-sizing-n5.linux.json new file mode 100644 index 00000000..ea58b8ad --- /dev/null +++ b/docs/evidence/p022-263a-sizing-n5.linux.json @@ -0,0 +1,3163 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "not_decision_evidence": "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about either engine. They cannot choose a threshold, a budget, a repetition count or a comparison statistic; those are D7's, frozen before the decisive run. No decisive workload was timed or resource-sampled to produce this file.", + "harness": { + "version": 1, + "digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "warmup_discards": 2, + "calibration_repetitions": 5, + "repetitions_note": "a CALIBRATION parameter for sizing the instrument, not the decisive N. The decisive N and its escalation ladder are preregistered by D7.", + "seed": 20260910, + "execution_order": [ + "core-full-sarif|rust|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-small|process-cold", + "core-usage|python|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-small|warm", + "core-full-human|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|warm", + "core-full-sarif|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|process-cold", + "core-full-sarif|python|cal-facts-tiny|warm", + "launcher-e2e|rust|cal-source-medium|warm", + "core-full-human|rust|cal-facts-small|process-cold", + "core-parse-refused|rust|cal-facts-refused|process-cold", + "core-full-sarif|python|cal-facts-medium|warm", + "core-full-human|rust|cal-facts-medium|warm", + "core-usage|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-small|warm", + "core-full-human|python|cal-facts-tiny|process-cold", + "core-full-human|rust|cal-facts-small|warm", + "core-usage|rust|cal-facts-tiny|process-cold", + "launcher-e2e|python|cal-source-small|warm", + "core-full-human|rust|cal-facts-tiny|warm", + "core-full-human|python|cal-facts-medium|warm", + "core-full-sarif|python|cal-facts-tiny|process-cold", + "core-full-sarif|python|cal-facts-medium|process-cold", + "core-full-human|python|cal-facts-small|process-cold", + "launcher-e2e|python|cal-source-medium|warm", + "launcher-e2e|rust|cal-source-small|process-cold", + "core-full-sarif|rust|cal-facts-medium|process-cold", + "core-full-sarif|rust|cal-facts-medium|warm", + "core-parse-refused|python|cal-facts-refused|warm", + "core-usage|python|cal-facts-tiny|process-cold", + "launcher-e2e|rust|cal-source-medium|process-cold", + "core-full-sarif|rust|cal-facts-tiny|process-cold", + "core-full-sarif|rust|cal-facts-tiny|warm", + "core-full-human|rust|cal-facts-tiny|process-cold", + "core-parse-refused|python|cal-facts-refused|process-cold", + "core-full-human|python|cal-facts-medium|process-cold", + "core-parse-refused|rust|cal-facts-refused|warm" + ] + }, + "identity": { + "gate_armed": false, + "gate_reason": "no D7 payload on disk: the freeze has not happened, so the gate is dormant by design and every decisive measurement is refused", + "gate_observed": { + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "harness_digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "harness_version": "1", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a" + }, + "gate_requirements": [ + "C1: a payload at p022-263a-d7-payload.json declaring kind='own.net/p022/d7-payload', carrying kind, schema, cells, rollups, instrument_anchor_commit, python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256, ratification", + "C1 carries a STRUCTURALLY COMPLETE preregistration: cells, rollups; each cell declares phase, workload_id, platform, regime and either bound, pass_fail_rule, inconclusive_band, repetition_ladder, comparison_statistic, rss_policy, allocation_policy (the ladder carrying initial_n, escalation_stages, transition_predicates, max_n, terminal_outcome) or an explicit not_applicable naming a reason in words; roll-ups carry workload_class, phase, overall_g3. Values are never read", + "C1 decides EVERY one of the 384 cells D7 covers — phase x workload_id x platform x regime over the frozen decisive manifest with aliases resolved — with no cell missing, unknown, or named twice", + "C1 declares instrument_anchor_commit S, and the instrument AT S hashes to the harness_digest C1 froze; S is an ancestor of C1. The CURRENT position is never required to equal S, because by #263-B it cannot be", + "C1's bindings equal what this process observes: python_reference_commit, python_reference_tree, harness_digest, harness_version, workload_manifest_sha256", + "C2: a detached attestation at p022-263a-d7-attestation.json declaring kind='own.net/p022/d7-attestation', carrying kind, schema, payload_path, payload_commit_sha, payload_blob_sha, payload_sha256, bindings, ratification_binding", + "C2's payload_sha256 equals the sha256 of the payload's EXACT BYTES", + "C2's payload_blob_sha equals the git blob sha of the payload at payload_commit_sha, and the payload's working-tree bytes are that blob", + "C2's own commit is a strict DESCENDANT of payload_commit_sha", + "C2's bindings and ratification_binding equal C1's", + "both objects are committed and unmodified in the working tree" + ], + "gate_pinned": {}, + "session_candidate": { + "path": "/home/user/Own.NET/rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "bytes": 1841648, + "frozen_at": "2026-09-10T15:56:06Z", + "measurements_taken": 200 + } + }, + "provenance": { + "tree_sha": "843d6fecfb38b2cf91f13ec179086f96705d7a88", + "tree_dirty": false, + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "python_interpreter": "3.11.15", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "environment": { + "platform": "linux", + "os": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "cpu_model": "Intel(R) Xeon(R) Processor @ 2.10GHz", + "cpu_count": 4, + "ram_bytes": 16856092672, + "python": "3.11.15", + "python_executable": "/usr/local/bin/python3", + "dotnet_sdk": "8.0.425", + "rustc": "rustc 1.94.1 (e408947bf 2026-03-25)", + "runner_class": "local", + "ci": false + }, + "timestamp_utc": "2026-09-10T15:58:38Z" + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: cheap, portable, and honestly named.", + "warm": "steady state after 2 DISCARDED iterations of the same cell. The process is still fresh each time; what is warm is the OS and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol (cache drop / reboot / fresh VM), and 'caches not pre-warmed' with no reset step means a different kind of cold on Windows than on Linux. A machine-cold claim without its reset protocol is inadmissible, so this instrument does not make one." + }, + "noise": { + "before": { + "median_ns": 14107284, + "iqr_ns": 442306.0, + "min_ns": 13749205, + "relative_iqr": 0.03135302301988108, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "after": { + "median_ns": 15330548, + "iqr_ns": 1688331.5, + "min_ns": 14213456, + "relative_iqr": 0.1101285811831384, + "iterations": 25, + "limit_relative_iqr": 0.35 + }, + "invalidated": false, + "invalidation_reasons": [] + }, + "phases": { + "process-startup-core": "user-visible? no — the child engine's own startup", + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before exiting; unavoidably inside the floor rung, which is why that rung is a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified" + }, + "rungs": [ + { + "id": "core-usage", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "usage-help", + "why": "The ladder FLOOR: the smallest real invocation the production surface allows — the process starts, parses argv, finds no document, writes a usage refusal and exits. It is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal message are inside this interval and cannot be separated out through the production surface without instrumentation #263-A is not authorized to add. Calling it 'startup' would let a later subtraction hand D7 a phase nobody measured." + }, + { + "id": "core-parse-refused", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "expect_rc": [ + 2 + ], + "evidence": "door-refusal", + "why": "A document the strict door refuses on its version. The read and parse happen; bridge and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the ownir read+parse cost only under an assumption this instrument never measures — that both invocations pay the same argv handling, and that cli-usage-refusal and ownir-door-refusal cost the same. They are different phases writing different text on different streams, so that second assumption is visibly an assumption. The difference is therefore a DERIVED bound, labelled as such, and never presented as a direct measurement of parse." + }, + { + "id": "core-full-human", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-human", + "why": "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was produced — 1 is 'leaks found', not a failure — and any other code means this interval timed something that is not the analysis path. bridge-lowering and analysis are not separately observable through the production surface and are recorded as members of this interval, not imputed from it." + }, + { + "id": "core-full-sarif", + "surface": "core", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "expect_rc": [ + 0, + 1 + ], + "evidence": "verdict-sarif", + "why": "The same path to the SARIF surface. Against core-full-human it gives a renderer DIFFERENCE, which is not the same quantity as rendering in isolation and is never reported as if it were." + }, + { + "id": "launcher-e2e", + "surface": "launcher", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "expect_rc": [ + 0 + ], + "evidence": "verdict-human", + "why": "The user-visible whole, through the production launcher with the engine explicitly selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed time, because an end-to-end number that shares one extraction between engines is a core comparison wearing an end-to-end hat." + } + ], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which #263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then runs the engine anyway, so an interval built on it contains the whole pipeline and cannot isolate extraction. Isolating it would need either a production launcher change or a direct extractor invocation, which is a different surface and not the launcher's extraction stage. Recorded as unavailable rather than invented; frontend-extraction is still measured as a member of launcher-e2e." + }, + "outcomes": { + "valid": true, + "cells_timed": 40, + "cells_refused": 0, + "problems": [], + "contract": { + "core-usage": { + "expected_exit_codes": [ + 2 + ], + "evidence": "usage-help" + }, + "core-parse-refused": { + "expected_exit_codes": [ + 2 + ], + "evidence": "door-refusal" + }, + "core-full-human": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-human" + }, + "core-full-sarif": { + "expected_exit_codes": [ + 0, + 1 + ], + "evidence": "verdict-sarif" + }, + "launcher-e2e": { + "expected_exit_codes": [ + 0 + ], + "evidence": "verdict-human" + } + } + }, + "workload_populations": { + "decisive": [ + "repo-samples", + "repo-examples", + "committed-corpus", + "oss-ShareX.repo", + "oss-ShareX.sln", + "oss-MahApps.Metro.repo", + "oss-MahApps.Metro.sln", + "oss-MaterialDesignInXamlToolkit.repo", + "oss-AvalonEdit.repo", + "oss-AvalonEdit.sln", + "oss-ClosedXML.repo", + "oss-ClosedXML.sln", + "large-solution-control" + ], + "calibration": [ + "cal-facts-tiny", + "cal-facts-small", + "cal-facts-medium", + "cal-facts-refused", + "cal-source-small", + "cal-source-medium" + ] + }, + "decisive_smoke": [ + { + "workload": "repo-samples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "repo-examples", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "committed-corpus", + "present": true, + "pin": null, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.repo", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ShareX.sln", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.repo", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MahApps.Metro.sln", + "present": false, + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-MaterialDesignInXamlToolkit.repo", + "present": false, + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.repo", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-AvalonEdit.sln", + "present": false, + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.repo", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "oss-ClosedXML.sln", + "present": false, + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "tag": "CALIBRATION_ONLY" + }, + { + "workload": "large-solution-control", + "present": false, + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "tag": "CALIBRATION_ONLY" + } + ], + "cells": [ + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2224517, + "min_ns": 1951258, + "mad_ns": 180495, + "iqr_ns": 372580.5, + "q1_ns": 1997640.0, + "q3_ns": 2370220.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25837568, + "min_bytes": 25837568, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25837568.0, + "q3_bytes": 25837568.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2452803, + 2287638, + 2224517, + 1951258, + 2044022 + ], + "raw_peak_rss_bytes": [ + 25837568, + 25837568, + 25837568, + 25837568, + 25837568 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2451047781, + "min_ns": 2322556545, + "mad_ns": 13826569, + "iqr_ns": 156453065.0, + "q1_ns": 2380871631.5, + "q3_ns": 2537324696.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213520384, + "min_bytes": 204124160, + "mad_bytes": 344064, + "iqr_bytes": 9603072.0, + "q1_bytes": 204161024.0, + "q3_bytes": 213764096.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2322556545, + 2439186718, + 2609775043, + 2451047781, + 2464874350 + ], + "raw_peak_rss_bytes": [ + 204124160, + 213663744, + 213520384, + 204197888, + 213864448 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 61391743, + "min_ns": 60567992, + "mad_ns": 823751, + "iqr_ns": 2945079.5, + "q1_ns": 60800663.0, + "q3_ns": 63745742.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25956352, + "min_bytes": 25956352, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25956352.0, + "q3_bytes": 25956352.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 60567992, + 61033334, + 62609892, + 64881593, + 61391743 + ], + "raw_peak_rss_bytes": [ + 25956352, + 25956352, + 25956352, + 25956352, + 25956352 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 85444911, + "min_ns": 84154927, + "mad_ns": 1285355, + "iqr_ns": 4317038.5, + "q1_ns": 84463430.0, + "q3_ns": 88780468.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25976832, + "min_bytes": 25976832, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25976832.0, + "q3_bytes": 25976832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 90830671, + 85444911, + 84154927, + 86730266, + 84771933 + ], + "raw_peak_rss_bytes": [ + 25976832, + 25976832, + 25976832, + 25976832, + 25976832 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2432955005, + "min_ns": 2363698672, + "mad_ns": 31218068, + "iqr_ns": 146845098.5, + "q1_ns": 2382717804.5, + "q3_ns": 2529562903.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 212680704, + "min_bytes": 204042240, + "mad_bytes": 688128, + "iqr_bytes": 9177088.0, + "q1_bytes": 204132352.0, + "q3_bytes": 213309440.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2436713615, + 2363698672, + 2622412191, + 2401736937, + 2432955005 + ], + "raw_peak_rss_bytes": [ + 212680704, + 204222464, + 213368832, + 204042240, + 213250048 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 85591621, + "min_ns": 83877303, + "mad_ns": 1109884, + "iqr_ns": 2420780.0, + "q1_ns": 84164340.0, + "q3_ns": 86585120.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25989120, + "min_bytes": 25989120, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25989120.0, + "q3_bytes": 25989120.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 86468735, + 85591621, + 84451377, + 83877303, + 86701505 + ], + "raw_peak_rss_bytes": [ + 25989120, + 25989120, + 25989120, + 25989120, + 25989120 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 84437682, + "min_ns": 82185985, + "mad_ns": 1096423, + "iqr_ns": 2568267.5, + "q1_ns": 82740998.0, + "q3_ns": 85309265.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25989120, + "min_bytes": 25989120, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25989120.0, + "q3_bytes": 25989120.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 83296011, + 84437682, + 85084426, + 85534105, + 82185985 + ], + "raw_peak_rss_bytes": [ + 25989120, + 25989120, + 25989120, + 25989120, + 25989120 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 85260955, + "min_ns": 84146911, + "mad_ns": 304276, + "iqr_ns": 1015028.5, + "q1_ns": 84551795.0, + "q3_ns": 85566823.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 25997312, + "min_bytes": 25997312, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 25997312.0, + "q3_bytes": 25997312.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84956679, + 85260955, + 85663775, + 84146911, + 85469872 + ], + "raw_peak_rss_bytes": [ + 25997312, + 25997312, + 25997312, + 25997312, + 25997312 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2528957366, + "min_ns": 2431670677, + "mad_ns": 33502850, + "iqr_ns": 123513911.5, + "q1_ns": 2433953579.5, + "q3_ns": 2557467491.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213504000, + "min_bytes": 204169216, + "mad_bytes": 540672, + "iqr_bytes": 9693184.0, + "q1_bytes": 204214272.0, + "q3_bytes": 213907456.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2528957366, + 2431670677, + 2562460216, + 2436236482, + 2552474766 + ], + "raw_peak_rss_bytes": [ + 213504000, + 204169216, + 213770240, + 204259328, + 214044672 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 83728475, + "min_ns": 82096068, + "mad_ns": 917101, + "iqr_ns": 2538981.5, + "q1_ns": 82453721.0, + "q3_ns": 84992702.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 84580945, + 85404460, + 83728475, + 82096068, + 82811374 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2544402279, + "min_ns": 2452739637, + "mad_ns": 57212750, + "iqr_ns": 128908669.5, + "q1_ns": 2469964583.0, + "q3_ns": 2598873252.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 212443136, + "min_bytes": 203730944, + "mad_bytes": 1835008, + "iqr_bytes": 10072064.0, + "q1_bytes": 203952128.0, + "q3_bytes": 214024192.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2554363995, + 2643382510, + 2452739637, + 2487189529, + 2544402279 + ], + "raw_peak_rss_bytes": [ + 204173312, + 214278144, + 212443136, + 203730944, + 213770240 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2372260, + "min_ns": 2280029, + "mad_ns": 92231, + "iqr_ns": 267814.5, + "q1_ns": 2284281.5, + "q3_ns": 2552096.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2630273, + 2280029, + 2288534, + 2473919, + 2372260 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1861320, + "min_ns": 1552696, + "mad_ns": 203976, + "iqr_ns": 527644.0, + "q1_ns": 1605020.0, + "q3_ns": 2132664.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1881643, + 1861320, + 2383685, + 1657344, + 1552696 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 106321667, + "min_ns": 95124286, + "mad_ns": 749738, + "iqr_ns": 6489518.5, + "q1_ns": 100275487.0, + "q3_ns": 106765005.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26005504, + "min_bytes": 26005504, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26005504.0, + "q3_bytes": 26005504.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 95124286, + 106321667, + 106458606, + 107071405, + 105426688 + ], + "raw_peak_rss_bytes": [ + 26005504, + 26005504, + 26005504, + 26005504, + 26005504 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 4888730, + "min_ns": 4680886, + "mad_ns": 112198, + "iqr_ns": 322986.5, + "q1_ns": 4759801.5, + "q3_ns": 5082788.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26009600, + "min_bytes": 26009600, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26009600.0, + "q3_bytes": 26009600.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4888730, + 5164648, + 4680886, + 5000928, + 4838717 + ], + "raw_peak_rss_bytes": [ + 26009600, + 26009600, + 26009600, + 26009600, + 26009600 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1406143, + "min_ns": 1350048, + "mad_ns": 56095, + "iqr_ns": 140698.5, + "q1_ns": 1374209.0, + "q3_ns": 1514907.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26009600, + "min_bytes": 26009600, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26009600.0, + "q3_bytes": 26009600.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1502270, + 1527545, + 1406143, + 1398370, + 1350048 + ], + "raw_peak_rss_bytes": [ + 26009600, + 26009600, + 26009600, + 26009600, + 26009600 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 4370487, + "min_ns": 4227817, + "mad_ns": 142670, + "iqr_ns": 402461.0, + "q1_ns": 4268703.5, + "q3_ns": 4671164.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26009600, + "min_bytes": 26009600, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26009600.0, + "q3_bytes": 26009600.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4670955, + 4671374, + 4309590, + 4227817, + 4370487 + ], + "raw_peak_rss_bytes": [ + 26009600, + 26009600, + 26009600, + 26009600, + 26009600 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1942949, + "min_ns": 1781771, + "mad_ns": 89898, + "iqr_ns": 211479.0, + "q1_ns": 1817411.0, + "q3_ns": 2028890.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26009600, + "min_bytes": 26009600, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26009600.0, + "q3_bytes": 26009600.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1853051, + 1781771, + 1962085, + 1942949, + 2095695 + ], + "raw_peak_rss_bytes": [ + 26009600, + 26009600, + 26009600, + 26009600, + 26009600 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 87034500, + "min_ns": 83441262, + "mad_ns": 1534234, + "iqr_ns": 6703520.5, + "q1_ns": 85213436.5, + "q3_ns": 91916957.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 83441262, + 86985611, + 95265180, + 88568734, + 87034500 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-small", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2118603, + "min_ns": 2060809, + "mad_ns": 57794, + "iqr_ns": 203705.5, + "q1_ns": 2084042.5, + "q3_ns": 2287748.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2360626, + 2118603, + 2214870, + 2107276, + 2060809 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1563387, + "min_ns": 1437331, + "mad_ns": 59009, + "iqr_ns": 150068.5, + "q1_ns": 1470854.5, + "q3_ns": 1620923.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1563387, + 1504378, + 1437331, + 1635158, + 1606688 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-small", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2456342690, + "min_ns": 2425009657, + "mad_ns": 12886267, + "iqr_ns": 113544003.5, + "q1_ns": 2436175108.5, + "q3_ns": 2549719112.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 212762624, + "min_bytes": 203530240, + "mad_bytes": 733184, + "iqr_bytes": 5496832.0, + "q1_bytes": 208128000.0, + "q3_bytes": 213624832.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2456342690, + 2425009657, + 2469228957, + 2630209267, + 2447340560 + ], + "raw_peak_rss_bytes": [ + 213495808, + 212762624, + 203530240, + 213753856, + 212725760 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1658548, + "min_ns": 1579468, + "mad_ns": 79080, + "iqr_ns": 186595.5, + "q1_ns": 1607910.5, + "q3_ns": 1794506.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1636353, + 1658548, + 1579468, + 1741585, + 1847427 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 93275499, + "min_ns": 91827701, + "mad_ns": 1121980, + "iqr_ns": 3158075.0, + "q1_ns": 92305630.5, + "q3_ns": 95463705.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 96529932, + 93275499, + 94397479, + 91827701, + 92783560 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 82559082, + "min_ns": 80842485, + "mad_ns": 1716597, + "iqr_ns": 6055302.0, + "q1_ns": 81551282.5, + "q3_ns": 87606584.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89665022, + 85548147, + 82559082, + 80842485, + 82260080 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 93408059, + "min_ns": 89955907, + "mad_ns": 3452152, + "iqr_ns": 23605196.5, + "q1_ns": 91453763.5, + "q3_ns": 115058960.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89955907, + 92951620, + 131336114, + 93408059, + 98781806 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-small", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 86424806, + "min_ns": 81107369, + "mad_ns": 2131400, + "iqr_ns": 5729500.0, + "q1_ns": 82700387.5, + "q3_ns": 88429887.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26013696, + "min_bytes": 26013696, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26013696.0, + "q3_bytes": 26013696.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 89124076, + 84293406, + 86424806, + 87735699, + 81107369 + ], + "raw_peak_rss_bytes": [ + 26013696, + 26013696, + 26013696, + 26013696, + 26013696 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "python", + "workload": "cal-source-medium", + "regime": "warm", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 2520564150, + "min_ns": 2459238593, + "mad_ns": 61325557, + "iqr_ns": 288662635.0, + "q1_ns": 2475524559.0, + "q3_ns": 2764187194.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 212934656, + "min_bytes": 203624448, + "mad_bytes": 1163264, + "iqr_bytes": 9979904.0, + "q1_bytes": 203909120.0, + "q3_bytes": 213889024.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2459238593, + 2708408126, + 2819966262, + 2520564150, + 2491810525 + ], + "raw_peak_rss_bytes": [ + 203624448, + 214097920, + 212934656, + 204193792, + 213680128 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-small", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2570573578, + "min_ns": 2479262155, + "mad_ns": 63863828, + "iqr_ns": 166863676.5, + "q1_ns": 2492985952.5, + "q3_ns": 2659849629.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 212824064, + "min_bytes": 203821056, + "mad_bytes": 1355776, + "iqr_bytes": 9955328.0, + "q1_bytes": 204019712.0, + "q3_bytes": 213975040.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2570573578, + 2735026264, + 2584672994, + 2479262155, + 2506709750 + ], + "raw_peak_rss_bytes": [ + 204218368, + 213770240, + 212824064, + 203821056, + 214179840 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 4666392, + "min_ns": 4553328, + "mad_ns": 83082, + "iqr_ns": 568929.5, + "q1_ns": 4589343.5, + "q3_ns": 5158273.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26050560, + "min_bytes": 26050560, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26050560.0, + "q3_bytes": 26050560.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 5567072, + 4749474, + 4553328, + 4666392, + 4625359 + ], + "raw_peak_rss_bytes": [ + 26050560, + 26050560, + 26050560, + 26050560, + 26050560 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-medium", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 5089507, + "min_ns": 4516313, + "mad_ns": 451654, + "iqr_ns": 1109414.0, + "q1_ns": 4634095.5, + "q3_ns": 5743509.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26050560, + "min_bytes": 26050560, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26050560.0, + "q3_bytes": 26050560.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 4751878, + 4516313, + 5541161, + 5945858, + 5089507 + ], + "raw_peak_rss_bytes": [ + 26050560, + 26050560, + 26050560, + 26050560, + 26050560 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 84140395, + "min_ns": 82482857, + "mad_ns": 1657538, + "iqr_ns": 11290618.0, + "q1_ns": 82688672.5, + "q3_ns": 93979290.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26050560, + "min_bytes": 26050560, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26050560.0, + "q3_bytes": 26050560.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 90824903, + 84140395, + 82894488, + 97133678, + 82482857 + ], + "raw_peak_rss_bytes": [ + 26050560, + 26050560, + 26050560, + 26050560, + 26050560 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-usage", + "engine": "python", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "cli-usage-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "usage-help", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 64780978, + "min_ns": 64504983, + "mad_ns": 275995, + "iqr_ns": 3408121.5, + "q1_ns": 64532646.0, + "q3_ns": 67940767.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26054656, + "min_bytes": 26054656, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26054656.0, + "q3_bytes": 26054656.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 67924227, + 64780978, + 64560309, + 67957308, + 64504983 + ], + "raw_peak_rss_bytes": [ + 26054656, + 26054656, + 26054656, + 26054656, + 26054656 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "launcher-e2e", + "engine": "rust", + "workload": "cal-source-medium", + "regime": "process-cold", + "phases": [ + "process-startup-launcher", + "frontend-extraction", + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "bash", + "/home/user/Own.NET/scripts/own-check.sh", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 2515819005, + "min_ns": 2422109588, + "mad_ns": 91570972, + "iqr_ns": 234182675.0, + "q1_ns": 2423178810.5, + "q3_ns": 2657361485.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 213311488, + "min_bytes": 203776000, + "mad_bytes": 442368, + "iqr_bytes": 5347328.0, + "q1_bytes": 208322560.0, + "q3_bytes": 213669888.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 2424248033, + 2719284549, + 2595438422, + 2515819005, + 2422109588 + ], + "raw_peak_rss_bytes": [ + 213897216, + 213442560, + 213311488, + 212869120, + 203776000 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1670546, + "min_ns": 1619106, + "mad_ns": 51440, + "iqr_ns": 233225.0, + "q1_ns": 1630574.0, + "q3_ns": 1863799.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26054656, + "min_bytes": 26054656, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26054656.0, + "q3_bytes": 26054656.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1891728, + 1835870, + 1642042, + 1670546, + 1619106 + ], + "raw_peak_rss_bytes": [ + 26054656, + 26054656, + 26054656, + 26054656, + 26054656 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-sarif", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-sarif" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-sarif", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1679562, + "min_ns": 1645894, + "mad_ns": 33668, + "iqr_ns": 128039.5, + "q1_ns": 1656663.0, + "q3_ns": 1784702.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26054656, + "min_bytes": 26054656, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26054656.0, + "q3_bytes": 26054656.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1781787, + 1679562, + 1645894, + 1787618, + 1667432 + ], + "raw_peak_rss_bytes": [ + 26054656, + 26054656, + 26054656, + 26054656, + 26054656 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "rust", + "workload": "cal-facts-tiny", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 1619721, + "min_ns": 1519827, + "mad_ns": 67810, + "iqr_ns": 160626.5, + "q1_ns": 1524940.0, + "q3_ns": 1685566.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26054656, + "min_bytes": 26054656, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26054656.0, + "q3_bytes": 26054656.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1687531, + 1519827, + 1683602, + 1530053, + 1619721 + ], + "raw_peak_rss_bytes": [ + 26054656, + 26054656, + 26054656, + 26054656, + 26054656 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "python", + "workload": "cal-facts-refused", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 85166278, + "min_ns": 80968970, + "mad_ns": 845190, + "iqr_ns": 3099013.0, + "q1_ns": 82565153.5, + "q3_ns": 85664166.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26054656, + "min_bytes": 26054656, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26054656.0, + "q3_bytes": 26054656.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 80968970, + 85166278, + 84161337, + 86011468, + 85316865 + ], + "raw_peak_rss_bytes": [ + 26054656, + 26054656, + 26054656, + 26054656, + 26054656 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-full-human", + "engine": "python", + "workload": "cal-facts-medium", + "regime": "process-cold", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 0, + 1 + ], + "observed_exit_code": 0, + "evidence": "verdict-human", + "valid": true, + "problems": [] + }, + "argv": [ + "/usr/local/bin/python3", + "<...>" + ], + "exit_codes": [ + 0 + ], + "warmup_discarded": 0, + "timing": { + "n": 5, + "median_ns": 107951310, + "min_ns": 102531227, + "mad_ns": 4227848, + "iqr_ns": 8247985.5, + "q1_ns": 103127344.5, + "q3_ns": 111375330.0 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26054656, + "min_bytes": 26054656, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26054656.0, + "q3_bytes": 26054656.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 103723462, + 107951310, + 110431615, + 102531227, + 112319045 + ], + "raw_peak_rss_bytes": [ + 26054656, + 26054656, + 26054656, + 26054656, + 26054656 + ], + "tag": "CALIBRATION_ONLY" + }, + { + "rung": "core-parse-refused", + "engine": "rust", + "workload": "cal-facts-refused", + "regime": "warm", + "phases": [ + "process-startup-core", + "cli-argv-parse", + "ownir-parse", + "ownir-door-refusal" + ], + "observability": "composed", + "outcome": { + "expected_exit_codes": [ + 2 + ], + "observed_exit_code": 2, + "evidence": "door-refusal", + "valid": true, + "problems": [] + }, + "argv": [ + "/home/user/Own.NET/rust/target/release/own-cli", + "<...>" + ], + "exit_codes": [ + 2 + ], + "warmup_discarded": 2, + "timing": { + "n": 5, + "median_ns": 1880666, + "min_ns": 1599340, + "mad_ns": 213902, + "iqr_ns": 830295.5, + "q1_ns": 1633052.0, + "q3_ns": 2463347.5 + }, + "peak_rss": { + "n": 5, + "median_bytes": 26054656, + "min_bytes": 26054656, + "mad_bytes": 0, + "iqr_bytes": 0.0, + "q1_bytes": 26054656.0, + "q3_bytes": 26054656.0 + }, + "rss_mechanism": "posix os.wait4 (ru_maxrss)", + "rss_unavailable_reason": "", + "raw_elapsed_ns": [ + 1880666, + 1666764, + 2977962, + 1948733, + 1599340 + ], + "raw_peak_rss_bytes": [ + 26054656, + 26054656, + 26054656, + 26054656, + 26054656 + ], + "tag": "CALIBRATION_ONLY" + } + ], + "reproducibility": { + "tag": "CALIBRATION_ONLY", + "earlier_run": { + "path": "p022-263a-sizing-n5-run-a.linux.json", + "sha256": "1b8697fff4a890ae67bfa5c84f1330d9f0b620f9050a3cbcf433d26e94ceca98", + "bytes": 79595, + "tree_sha": "843d6fecfb38b2cf91f13ec179086f96705d7a88", + "tree_dirty": false, + "python_reference_commit": "20879db170e6edf1dfd18c0488e15d611f15e912", + "python_reference_tree": "d6031f5ee384aafc4c7f92fe5c9ad2a63b144562", + "workload_manifest_sha256": "ecfee52f905321ad143c280fe8f7f91b8fef4d0da66de9155aabd175c131ef8a", + "harness_digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "calibration_repetitions": 5, + "warmup_discards": 2, + "candidate_sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "candidate_bytes": 1841648 + }, + "compared_cells": 40, + "tolerance_relative": 0.35, + "tolerance_source": "REPRODUCIBILITY_MAX_MEDIAN_CHANGE, a fixed policy constant. It is CHOSEN, not derived from this run; what makes it admissible is that it was chosen before the runs it judges, and it is not adjusted after seeing which of them it rejects.", + "cells_only_in_earlier": [], + "cells_only_in_later": [], + "cells_outside_tolerance": [], + "cells_whose_outcome_changed": [], + "outcomes_reproduced": true, + "timings_reproduced": true, + "reproduced": true + }, + "admissibility": { + "outcomes_reproduced": true, + "timings_reproduced": true, + "environment_valid": true, + "admissible": true, + "note": "all three axes are required for a report of record. A run that fails timings_reproduced has not established WHY: a contended runner, a variable workload and an uncertain median estimate all look the same here." + } +} diff --git a/docs/evidence/p022-263a-workloads.json b/docs/evidence/p022-263a-workloads.json new file mode 100644 index 00000000..2397b2cc --- /dev/null +++ b/docs/evidence/p022-263a-workloads.json @@ -0,0 +1,172 @@ +{ + "schema": 1, + "comment": "#263-A FROZEN workload manifest. Two populations that must never be confused: DECISIVE workloads feed the D7 cutover verdict and MUST NOT be run in timed or resource-measured mode before the D7 freeze; CALIBRATION workloads exist only to validate the instrument and can never pick a threshold. The split is why calibration can happen at all without anybody having peeked at the Rust-vs-Python delta — 'we did not save it' is accounting-clean, not epistemically clean.", + "populations": { + "decisive": "The G3 cutover subset (#262's Performance gates) plus #262's large-solution control. Pinned by commit; drift is a FAILED TARGET, never a newer measurement. Pre-D7 these may be enumerated, hashed, fetched, availability-checked and exercised by NON-TIMED structural smoke only.", + "calibration": "Generated deterministically by the harness from this manifest, so they are separate from the decisive corpus by construction rather than by discipline. Every result over them is tagged CALIBRATION_ONLY." + }, + "decisive": [ + { + "id": "repo-samples", + "kind": "source-tree", + "path": "frontend/roslyn/samples", + "why": "the committed C# sample tree — the small end of the decisive size ladder" + }, + { + "id": "repo-examples", + "kind": "source-tree", + "path": "examples", + "why": "the committed examples tree — the medium rung" + }, + { + "id": "committed-corpus", + "kind": "source-tree", + "path": "corpus", + "why": "#263's 'corpus batch' and #262's committed-corpus gate" + }, + { + "id": "oss-ShareX.repo", + "kind": "source-tree", + "path": "targets/ShareX", + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "why": "one of the five pinned OSS repositories of #243, whole-tree walk, at its verified pin" + }, + { + "id": "oss-ShareX.sln", + "kind": "source-tree", + "path": "targets/ShareX/ShareX.sln", + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "why": "the largest solution of ShareX — a different extractor path and a differently ORDERED document, not a subset of the repo walk" + }, + { + "id": "oss-MahApps.Metro.repo", + "kind": "source-tree", + "path": "targets/MahApps.Metro", + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "why": "one of the five pinned OSS repositories of #243, whole-tree walk, at its verified pin" + }, + { + "id": "oss-MahApps.Metro.sln", + "kind": "source-tree", + "path": "targets/MahApps.Metro/src/MahApps.Metro.sln", + "pin": { + "repository": "MahApps/MahApps.Metro", + "commit": "72099e310bac2d12ac98fd7560b69679252519f5" + }, + "why": "the largest solution of MahApps.Metro — a different extractor path and a differently ORDERED document, not a subset of the repo walk" + }, + { + "id": "oss-MaterialDesignInXamlToolkit.repo", + "kind": "source-tree", + "path": "targets/MaterialDesignInXamlToolkit", + "pin": { + "repository": "MaterialDesignInXAML/MaterialDesignInXamlToolkit", + "commit": "ef3a5ea434e39182b1848f5e11aaea6b3890581f" + }, + "why": "one of the five pinned OSS repositories of #243, whole-tree walk, at its verified pin" + }, + { + "id": "oss-AvalonEdit.repo", + "kind": "source-tree", + "path": "targets/AvalonEdit", + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "why": "one of the five pinned OSS repositories of #243, whole-tree walk, at its verified pin" + }, + { + "id": "oss-AvalonEdit.sln", + "kind": "source-tree", + "path": "targets/AvalonEdit/ICSharpCode.AvalonEdit.sln", + "pin": { + "repository": "icsharpcode/AvalonEdit", + "commit": "ed0bd149059469ac9bd39b13cf8a341b12a6c1da" + }, + "why": "the largest solution of AvalonEdit — a different extractor path and a differently ORDERED document, not a subset of the repo walk" + }, + { + "id": "oss-ClosedXML.repo", + "kind": "source-tree", + "path": "targets/ClosedXML", + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "why": "one of the five pinned OSS repositories of #243, whole-tree walk, at its verified pin" + }, + { + "id": "oss-ClosedXML.sln", + "kind": "source-tree", + "path": "targets/ClosedXML/ClosedXML.sln", + "pin": { + "repository": "ClosedXML/ClosedXML", + "commit": "4e89dcedd83cad553e84d2d97f77fc3d7deb630f" + }, + "why": "the largest solution of ClosedXML — a different extractor path and a differently ORDERED document, not a subset of the repo walk" + }, + { + "id": "large-solution-control", + "kind": "source-tree", + "path": "targets/ShareX/ShareX.sln", + "pin": { + "repository": "ShareX/ShareX", + "commit": "0df9ca4d83eed9d2489048c539d7d1fc2860fdec" + }, + "alias_of": "oss-ShareX.sln", + "why": "#262's large-solution control. Declared under its own id because the gate names it, and recorded as an ALIAS so it is never counted twice in a denominator" + } + ], + "calibration": [ + { + "id": "cal-facts-tiny", + "kind": "generated-facts", + "generator": "facts", + "scale": 1, + "why": "instrument-sizing only: the smallest document the door accepts" + }, + { + "id": "cal-facts-small", + "kind": "generated-facts", + "generator": "facts", + "scale": 25, + "why": "instrument-sizing only" + }, + { + "id": "cal-facts-medium", + "kind": "generated-facts", + "generator": "facts", + "scale": 250, + "why": "instrument-sizing only: large enough that analysis is not lost in startup" + }, + { + "id": "cal-facts-refused", + "kind": "generated-facts", + "generator": "refused", + "why": "a document the strict door REFUSES: the parse rung, which stops before bridge and analysis" + }, + { + "id": "cal-source-small", + "kind": "generated-source", + "generator": "csharp", + "scale": 4, + "why": "instrument-sizing only: a synthetic C# tree for the launcher rungs" + }, + { + "id": "cal-source-medium", + "kind": "generated-source", + "generator": "csharp", + "scale": 40, + "why": "instrument-sizing only" + } + ] +} diff --git a/docs/evidence/p022-stage2-census.json b/docs/evidence/p022-stage2-census.json index 34203fbd..04ec854c 100644 --- a/docs/evidence/p022-stage2-census.json +++ b/docs/evidence/p022-stage2-census.json @@ -7,7 +7,7 @@ "C": "COMPARE GATE. Runs both engines under the ratified #260 / Stage-1 differential contract. Stage 2 increases Rust exposure and must never pay for it with differential evidence, so these are neither weakened nor relabelled.", "D": "OPERATIONAL SELF-DOGFOOD. Own.NET running Owen over its own code as the engine under test — not verifying the public default, not acting as a reference. This is the Stage-2 Rust-default population: every Class-D call site selects Rust EXPLICITLY through the ratified launcher contract, with the production `own-cli` supplied via OWEN_RUST_CORE." }, - "entry_points_comment": "What counts as executing the core. The launcher surfaces are direct; the wrapper entries are scripts that invoke a launcher or the core themselves, listed so an indirect call site cannot escape the census by adding one level of indirection. Two negative lookaheads are deliberate and were measured, not guessed: `benchmark.py --selftest` validates the scoring and SARIF-parsing logic against embedded fixtures with no SDK, and `shadow_sweep.py --collect`/`--result` assemble and check a record of legs that ran elsewhere. Neither executes the analysis core, so neither is a call site; counting them would inflate the denominator with runs that analyse nothing. Comment lines and `paths:` filters are stripped for the same reason.", + "entry_points_comment": "What counts as executing the core. The launcher surfaces are direct; the wrapper entries are scripts that invoke a launcher or the core themselves, listed so an indirect call site cannot escape the census by adding one level of indirection. That list is a closed enumeration and therefore a maintenance obligation: a NEW wrapper script must be added here when it lands, or the job that runs it is invisible to the census. scripts/perf_baseline.py (#263-A) is the first one added under that rule. Two negative lookaheads are deliberate and were measured, not guessed: `benchmark.py --selftest` validates the scoring and SARIF-parsing logic against embedded fixtures with no SDK, and `shadow_sweep.py --collect`/`--result` assemble and check a record of legs that ran elsewhere. Neither executes the analysis core, so neither is a call site; counting them would inflate the denominator with runs that analyse nothing. Comment lines and `paths:` filters are stripped for the same reason.", "entry_points": [ "scripts/own-check\\.sh", "scripts/own-check\\.ps1", @@ -18,7 +18,8 @@ "scripts/benchmark\\.py(?!.*--selftest)", "tests/shadow_sweep\\.py(?!.*(--collect|--result))", "cargo test[^\\n]*-p own-cli", - "scripts/mutate_campaign\\.py" + "scripts/mutate_campaign\\.py", + "scripts/perf_baseline\\.py" ], "call_sites": [ { @@ -27,6 +28,12 @@ "class": "B", "why": "Replays the frozen Python-authored CLI fixture family against the built Rust `own-cli` with zero Python at run time. The measurement IS the parity between the two implementations, so it is engine-specific by construction and has no default to move." }, + { + "workflow": ".github/workflows/ci.yml", + "job": "perf-instrument", + "class": "B", + "why": "#263-A's measurement instrument, calibrating. It drives BOTH engines through the production launcher, but it is not a compare gate: it produces no engine comparison and structurally refuses to, and it measures no decisive workload before the D7 freeze. A deliberately engine-specific measurement whose subject is the instrument rather than either engine." + }, { "workflow": ".github/workflows/ci.yml", "job": "stage1-engine", diff --git a/docs/evidence/round6/p022-263a-round6-metrology.linux.json b/docs/evidence/round6/p022-263a-round6-metrology.linux.json new file mode 100644 index 00000000..60542c56 --- /dev/null +++ b/docs/evidence/round6/p022-263a-round6-metrology.linux.json @@ -0,0 +1,6577 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "kind": "own.net/p022/round6-metrology", + "not_decision_evidence": "Variance characterisation of the instrument's timed interval. NO pass/fail tolerance is computed or applied here, and no value in this file may be used as a D7 threshold.", + "preregistration": "docs/notes/p022-263a-round6-preregistration.md", + "helper_sha256": "f937b36bd4dac422f88942b87ea9794e2c75a198a034917e6c02c0abad1c0cbd", + "spawn_floor_ms": 1.332, + "warmup_discards": 2, + "sessions_per_cell": 5, + "instrument_harness_digest": "2d6e52fe43529456c00249d967148035423f9bba938de7f9f0f960832c8e0a6a", + "instrument_tree_sha": "8c61a7b204a1dfde5c6b103d841c046882d83c84", + "platform": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "timestamp_utc": "2026-09-10T16:32:31Z", + "cells": [ + { + "target_ms": 1, + "iterations": 0, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 1238038, + "mad_ns": 35201, + "iqr_ns": 144612.5, + "min_ns": 1202837, + "max_ns": 1375732, + "n": 5 + }, + "b": { + "median_ns": 1278132, + "mad_ns": 40623, + "iqr_ns": 125101.5, + "min_ns": 1237509, + "max_ns": 1400750, + "n": 5 + }, + "raw_a_ns": [ + 1375732, + 1238038, + 1236119, + 1352449, + 1202837 + ], + "raw_b_ns": [ + 1345590, + 1278132, + 1400750, + 1237509, + 1258628 + ], + "absolute_median_shift_ns": 40094, + "relative_median_shift": 0.03238511257328127, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 12, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303133 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 40, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303241 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 1489581, + "mad_ns": 40035, + "iqr_ns": 355414.5, + "min_ns": 1141137, + "max_ns": 1529616, + "n": 5 + }, + "b": { + "median_ns": 1499611, + "mad_ns": 53044, + "iqr_ns": 219148.0, + "min_ns": 1213435, + "max_ns": 1553361, + "n": 5 + }, + "raw_a_ns": [ + 1514179, + 1191829, + 1141137, + 1529616, + 1489581 + ], + "raw_b_ns": [ + 1213435, + 1544937, + 1499611, + 1446567, + 1553361 + ], + "absolute_median_shift_ns": 10030, + "relative_median_shift": 0.006733437120908497, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 40, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303245 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 68, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303350 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 1629986, + "mad_ns": 51220, + "iqr_ns": 192530.5, + "min_ns": 1392419, + "max_ns": 1681206, + "n": 5 + }, + "b": { + "median_ns": 1261155, + "mad_ns": 99178, + "iqr_ns": 317217.0, + "min_ns": 1161977, + "max_ns": 1513060, + "n": 5 + }, + "raw_a_ns": [ + 1681206, + 1647163, + 1550889, + 1392419, + 1629986 + ], + "raw_b_ns": [ + 1261155, + 1229151, + 1512502, + 1513060, + 1161977 + ], + "absolute_median_shift_ns": 368831, + "relative_median_shift": 0.22627863061400527, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 68, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303350 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 96, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303465 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 1481824, + "mad_ns": 24092, + "iqr_ns": 91431.5, + "min_ns": 1457732, + "max_ns": 1565816, + "n": 5 + }, + "b": { + "median_ns": 1546840, + "mad_ns": 47049, + "iqr_ns": 165213.0, + "min_ns": 1411819, + "max_ns": 1593889, + "n": 5 + }, + "raw_a_ns": [ + 1467811, + 1565816, + 1457732, + 1542590, + 1481824 + ], + "raw_b_ns": [ + 1411819, + 1576967, + 1593889, + 1546840, + 1428611 + ], + "absolute_median_shift_ns": 65016, + "relative_median_shift": 0.04387565594834474, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 96, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303465 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 124, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303599 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 1520633, + "mad_ns": 65118, + "iqr_ns": 177656.0, + "min_ns": 1416534, + "max_ns": 1655807, + "n": 5 + }, + "b": { + "median_ns": 1464228, + "mad_ns": 35389, + "iqr_ns": 105241.5, + "min_ns": 1428839, + "max_ns": 1550766, + "n": 5 + }, + "raw_a_ns": [ + 1655807, + 1416534, + 1520633, + 1455515, + 1571554 + ], + "raw_b_ns": [ + 1464228, + 1550766, + 1522471, + 1433915, + 1428839 + ], + "absolute_median_shift_ns": 56405, + "relative_median_shift": 0.037093105305487914, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 124, + "nonvoluntary_ctxt_switches": 7, + "system_ctxt": 303599 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 152, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 303723 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 1239453, + "mad_ns": 100881, + "iqr_ns": 337038.0, + "min_ns": 1108076, + "max_ns": 1509309, + "n": 15 + }, + "b": { + "median_ns": 1229306, + "mad_ns": 50651, + "iqr_ns": 105207.0, + "min_ns": 1132501, + "max_ns": 1312683, + "n": 15 + }, + "raw_a_ns": [ + 1138572, + 1476546, + 1310704, + 1502893, + 1139508, + 1108076, + 1507521, + 1239453, + 1368816, + 1207717, + 1169703, + 1509309, + 1116390, + 1268444, + 1158500 + ], + "raw_b_ns": [ + 1239988, + 1283862, + 1154976, + 1132501, + 1201718, + 1193810, + 1181514, + 1312683, + 1229306, + 1294574, + 1250921, + 1271235, + 1178655, + 1308242, + 1152161 + ], + "absolute_median_shift_ns": 10147, + "relative_median_shift": 0.008186675896544685, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 152, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 303724 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 220, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 303976 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 1385639, + "mad_ns": 57106, + "iqr_ns": 155073.0, + "min_ns": 1198081, + "max_ns": 1602526, + "n": 15 + }, + "b": { + "median_ns": 1352984, + "mad_ns": 71789, + "iqr_ns": 167244.0, + "min_ns": 1174767, + "max_ns": 1619336, + "n": 15 + }, + "raw_a_ns": [ + 1257522, + 1473143, + 1602526, + 1208785, + 1394014, + 1198081, + 1442745, + 1429218, + 1380502, + 1358148, + 1577215, + 1384462, + 1385639, + 1287672, + 1400203 + ], + "raw_b_ns": [ + 1261046, + 1174767, + 1403583, + 1448439, + 1313559, + 1281195, + 1575980, + 1288030, + 1619336, + 1451000, + 1304816, + 1377173, + 1247026, + 1352984, + 1389153 + ], + "absolute_median_shift_ns": 32655, + "relative_median_shift": 0.02356674429631383, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.1826171875, + 0.10302734375, + 0.03125 + ], + "voluntary_ctxt_switches": 220, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 303976 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 288, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 304245 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 1423167, + "mad_ns": 64781, + "iqr_ns": 244399.0, + "min_ns": 1267215, + "max_ns": 2276303, + "n": 15 + }, + "b": { + "median_ns": 1357181, + "mad_ns": 72211, + "iqr_ns": 117641.0, + "min_ns": 1210889, + "max_ns": 4390127, + "n": 15 + }, + "raw_a_ns": [ + 1455355, + 1367095, + 1392916, + 1602785, + 1333564, + 1782522, + 2276303, + 1871823, + 1482789, + 1267215, + 1358386, + 1439698, + 1285362, + 1423167, + 1400787 + ], + "raw_b_ns": [ + 1357181, + 1284970, + 4390127, + 1481737, + 1281495, + 1881294, + 1297155, + 1328381, + 1244924, + 1210889, + 1235692, + 1363645, + 1399136, + 1364388, + 1375722 + ], + "absolute_median_shift_ns": 65986, + "relative_median_shift": 0.046365605723010725, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 288, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 304245 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 356, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 304503 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 1357817, + "mad_ns": 101732, + "iqr_ns": 226619.0, + "min_ns": 1179676, + "max_ns": 1699812, + "n": 15 + }, + "b": { + "median_ns": 1277525, + "mad_ns": 110515, + "iqr_ns": 338655.0, + "min_ns": 1142056, + "max_ns": 1670739, + "n": 15 + }, + "raw_a_ns": [ + 1459549, + 1584161, + 1488010, + 1411009, + 1699812, + 1356682, + 1333875, + 1560494, + 1338152, + 1208870, + 1346580, + 1597798, + 1297109, + 1179676, + 1357817 + ], + "raw_b_ns": [ + 1203713, + 1277525, + 1142056, + 1341769, + 1167010, + 1192604, + 1204770, + 1384240, + 1531259, + 1658000, + 1266151, + 1670739, + 1162758, + 1472703, + 1664605 + ], + "absolute_median_shift_ns": 80292, + "relative_median_shift": 0.05913315270025342, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 356, + "nonvoluntary_ctxt_switches": 8, + "system_ctxt": 304503 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 424, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 304769 + } + }, + { + "target_ms": 1, + "iterations": 0, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 1312269, + "mad_ns": 56224, + "iqr_ns": 120614.0, + "min_ns": 1173764, + "max_ns": 1807462, + "n": 15 + }, + "b": { + "median_ns": 1187487, + "mad_ns": 36667, + "iqr_ns": 98585.0, + "min_ns": 1037892, + "max_ns": 1680008, + "n": 15 + }, + "raw_a_ns": [ + 1360983, + 1606243, + 1391785, + 1807462, + 1297434, + 1328849, + 1546941, + 1302722, + 1284718, + 1255265, + 1368493, + 1271171, + 1312269, + 1173764, + 1197272 + ], + "raw_b_ns": [ + 1289077, + 1345138, + 1187487, + 1162392, + 1037892, + 1090192, + 1181381, + 1680008, + 1187995, + 1095881, + 1183169, + 1223714, + 1224154, + 1260977, + 1185994 + ], + "absolute_median_shift_ns": 124782, + "relative_median_shift": 0.09508873561746868, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 424, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 304769 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 492, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305017 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 1960246, + "mad_ns": 59423, + "iqr_ns": 123140.0, + "min_ns": 1891266, + "max_ns": 2032939, + "n": 5 + }, + "b": { + "median_ns": 2052750, + "mad_ns": 99549, + "iqr_ns": 187984.5, + "min_ns": 1921020, + "max_ns": 2196779, + "n": 5 + }, + "raw_a_ns": [ + 1891266, + 2005430, + 1960246, + 2032939, + 1900823 + ], + "raw_b_ns": [ + 1921020, + 2053411, + 2052750, + 1953201, + 2196779 + ], + "absolute_median_shift_ns": 92504, + "relative_median_shift": 0.04718999554137593, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 492, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305018 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 520, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305144 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 1989273, + "mad_ns": 78054, + "iqr_ns": 201477.5, + "min_ns": 1833669, + "max_ns": 2067327, + "n": 5 + }, + "b": { + "median_ns": 1940266, + "mad_ns": 27829, + "iqr_ns": 56232.0, + "min_ns": 1905804, + "max_ns": 1981761, + "n": 5 + }, + "raw_a_ns": [ + 2067327, + 1857096, + 1833669, + 1989273, + 2026393 + ], + "raw_b_ns": [ + 1905804, + 1981761, + 1912437, + 1948944, + 1940266 + ], + "absolute_median_shift_ns": 49007, + "relative_median_shift": 0.024635633218768868, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 520, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305144 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 548, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305253 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 1949293, + "mad_ns": 21074, + "iqr_ns": 73275.5, + "min_ns": 1890482, + "max_ns": 1970367, + "n": 5 + }, + "b": { + "median_ns": 1887838, + "mad_ns": 26516, + "iqr_ns": 90902.5, + "min_ns": 1861322, + "max_ns": 1971655, + "n": 5 + }, + "raw_a_ns": [ + 1902535, + 1890482, + 1970367, + 1969201, + 1949293 + ], + "raw_b_ns": [ + 1958209, + 1886737, + 1887838, + 1971655, + 1861322 + ], + "absolute_median_shift_ns": 61455, + "relative_median_shift": 0.03152681510681052, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 548, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305253 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 576, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305366 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 2000410, + "mad_ns": 27660, + "iqr_ns": 142906.0, + "min_ns": 1964974, + "max_ns": 2217691, + "n": 5 + }, + "b": { + "median_ns": 2110239, + "mad_ns": 18211, + "iqr_ns": 121059.5, + "min_ns": 1919111, + "max_ns": 2131698, + "n": 5 + }, + "raw_a_ns": [ + 1972750, + 2005845, + 2000410, + 1964974, + 2217691 + ], + "raw_b_ns": [ + 1919111, + 2131698, + 2110239, + 2128450, + 2098918 + ], + "absolute_median_shift_ns": 109829, + "relative_median_shift": 0.054903244834808865, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 576, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305366 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 604, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305478 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 2047687, + "mad_ns": 84634, + "iqr_ns": 205016.5, + "min_ns": 1901306, + "max_ns": 2212462, + "n": 5 + }, + "b": { + "median_ns": 2367963, + "mad_ns": 175528, + "iqr_ns": 454674.5, + "min_ns": 2039291, + "max_ns": 2634489, + "n": 5 + }, + "raw_a_ns": [ + 2132321, + 2033444, + 2047687, + 2212462, + 1901306 + ], + "raw_b_ns": [ + 2367963, + 2039291, + 2192435, + 2634489, + 2506586 + ], + "absolute_median_shift_ns": 320276, + "relative_median_shift": 0.15640866987972282, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 604, + "nonvoluntary_ctxt_switches": 9, + "system_ctxt": 305478 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 632, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 305604 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 2123623, + "mad_ns": 111793, + "iqr_ns": 256765.0, + "min_ns": 1882322, + "max_ns": 2855217, + "n": 15 + }, + "b": { + "median_ns": 2015043, + "mad_ns": 60938, + "iqr_ns": 122671.0, + "min_ns": 1901975, + "max_ns": 2136585, + "n": 15 + }, + "raw_a_ns": [ + 2855217, + 2129129, + 2115573, + 2185207, + 1994196, + 2434205, + 2172423, + 2120991, + 2196752, + 1939987, + 1882322, + 2235416, + 1939220, + 1892058, + 2123623 + ], + "raw_b_ns": [ + 1945423, + 2031536, + 2014706, + 1910709, + 1901975, + 2086233, + 1954105, + 2015043, + 1975540, + 2036357, + 2007726, + 2076776, + 2036864, + 2136585, + 2114040 + ], + "absolute_median_shift_ns": 108580, + "relative_median_shift": 0.05112960257070111, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 632, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 305606 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 700, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 305882 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 2101672, + "mad_ns": 97620, + "iqr_ns": 217099.0, + "min_ns": 1893675, + "max_ns": 2314395, + "n": 15 + }, + "b": { + "median_ns": 2074132, + "mad_ns": 102512, + "iqr_ns": 205948.0, + "min_ns": 1887984, + "max_ns": 2464388, + "n": 15 + }, + "raw_a_ns": [ + 2090534, + 2048741, + 2314395, + 2103011, + 2013982, + 2209993, + 2193098, + 1982193, + 2287540, + 2199292, + 2101672, + 2110290, + 1973839, + 1964233, + 1893675 + ], + "raw_b_ns": [ + 1971620, + 2464388, + 1977305, + 2257468, + 1887984, + 2011905, + 2146791, + 2348836, + 2071835, + 2217853, + 2074132, + 2208063, + 2062534, + 2211564, + 2031104 + ], + "absolute_median_shift_ns": 27540, + "relative_median_shift": 0.01310385255168266, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 700, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 305882 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 768, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 306185 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 2177854, + "mad_ns": 117145, + "iqr_ns": 220965.0, + "min_ns": 1955031, + "max_ns": 2710138, + "n": 15 + }, + "b": { + "median_ns": 1967133, + "mad_ns": 31314, + "iqr_ns": 234823.0, + "min_ns": 1864958, + "max_ns": 2462431, + "n": 15 + }, + "raw_a_ns": [ + 2202250, + 2257031, + 2058724, + 2117486, + 2294999, + 1956851, + 2177854, + 1994041, + 2214662, + 2344336, + 2036066, + 2197576, + 2710138, + 2061739, + 1955031 + ], + "raw_b_ns": [ + 1888844, + 1932862, + 1967133, + 1935819, + 1954525, + 1966343, + 1940194, + 1989681, + 1984251, + 1864958, + 2288059, + 2462431, + 2170642, + 1994745, + 2309801 + ], + "absolute_median_shift_ns": 210721, + "relative_median_shift": 0.09675625638816927, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 768, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 306185 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 836, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 306462 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 2142063, + "mad_ns": 81735, + "iqr_ns": 175378.0, + "min_ns": 1894970, + "max_ns": 2561417, + "n": 15 + }, + "b": { + "median_ns": 2049436, + "mad_ns": 86212, + "iqr_ns": 209871.0, + "min_ns": 1889455, + "max_ns": 2527311, + "n": 15 + }, + "raw_a_ns": [ + 2202905, + 1894970, + 2027527, + 2168866, + 2142063, + 2168723, + 2222068, + 2426937, + 2079198, + 1988753, + 2180803, + 1931507, + 2060328, + 2561417, + 2045088 + ], + "raw_b_ns": [ + 1925777, + 1889455, + 1891487, + 2049436, + 2040541, + 2016932, + 2135648, + 2066225, + 2275840, + 2017781, + 2224986, + 1922209, + 2073293, + 2527311, + 2101215 + ], + "absolute_median_shift_ns": 92627, + "relative_median_shift": 0.043241958803265826, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 836, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 306462 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 904, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 306735 + } + }, + { + "target_ms": 2, + "iterations": 460280, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 2020638, + "mad_ns": 76622, + "iqr_ns": 155824.0, + "min_ns": 1890499, + "max_ns": 2193687, + "n": 15 + }, + "b": { + "median_ns": 1993052, + "mad_ns": 52317, + "iqr_ns": 135053.0, + "min_ns": 1825238, + "max_ns": 2179553, + "n": 15 + }, + "raw_a_ns": [ + 2116442, + 2193687, + 1925367, + 1891112, + 2066500, + 2020638, + 2041308, + 2070244, + 2066408, + 2011155, + 1910676, + 1896024, + 1890499, + 1944016, + 2063632 + ], + "raw_b_ns": [ + 1960877, + 1994591, + 1940735, + 2048250, + 1977614, + 2179553, + 2029186, + 1894440, + 1865334, + 1995302, + 1825238, + 1993052, + 2071763, + 2030088, + 1895035 + ], + "absolute_median_shift_ns": 27586, + "relative_median_shift": 0.013652123735176712, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 904, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 306735 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 972, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307000 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 3958928, + "mad_ns": 26674, + "iqr_ns": 85081.5, + "min_ns": 3925728, + "max_ns": 4045440, + "n": 5 + }, + "b": { + "median_ns": 4088085, + "mad_ns": 15720, + "iqr_ns": 113064.5, + "min_ns": 3999428, + "max_ns": 4197776, + "n": 5 + }, + "raw_a_ns": [ + 3958928, + 3932254, + 3925728, + 3982705, + 4045440 + ], + "raw_b_ns": [ + 3999428, + 4103805, + 4076024, + 4197776, + 4088085 + ], + "absolute_median_shift_ns": 129157, + "relative_median_shift": 0.032624235651671364, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 972, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307002 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1000, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307138 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 3962822, + "mad_ns": 63548, + "iqr_ns": 206173.0, + "min_ns": 3888673, + "max_ns": 4193232, + "n": 5 + }, + "b": { + "median_ns": 4099746, + "mad_ns": 22959, + "iqr_ns": 76460.0, + "min_ns": 4076787, + "max_ns": 4184703, + "n": 5 + }, + "raw_a_ns": [ + 3899274, + 3962822, + 3888673, + 4007061, + 4193232 + ], + "raw_b_ns": [ + 4083025, + 4076787, + 4099746, + 4128029, + 4184703 + ], + "absolute_median_shift_ns": 136924, + "relative_median_shift": 0.03455214491087412, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1000, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307138 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1028, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307335 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 3957479, + "mad_ns": 45197, + "iqr_ns": 87825.5, + "min_ns": 3893531, + "max_ns": 4002676, + "n": 5 + }, + "b": { + "median_ns": 4055338, + "mad_ns": 105647, + "iqr_ns": 226123.5, + "min_ns": 3928409, + "max_ns": 4220636, + "n": 5 + }, + "raw_a_ns": [ + 3957479, + 4002676, + 3893531, + 3905084, + 3971590 + ], + "raw_b_ns": [ + 4109711, + 4055338, + 3949691, + 3928409, + 4220636 + ], + "absolute_median_shift_ns": 97859, + "relative_median_shift": 0.024727610683467936, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1028, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307335 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1056, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307467 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 3949052, + "mad_ns": 8142, + "iqr_ns": 66386.0, + "min_ns": 3919071, + "max_ns": 4038509, + "n": 5 + }, + "b": { + "median_ns": 3900214, + "mad_ns": 5481, + "iqr_ns": 84936.5, + "min_ns": 3894733, + "max_ns": 3987821, + "n": 5 + }, + "raw_a_ns": [ + 3954244, + 3949052, + 3940910, + 3919071, + 4038509 + ], + "raw_b_ns": [ + 3987821, + 3974856, + 3900214, + 3898071, + 3894733 + ], + "absolute_median_shift_ns": 48838, + "relative_median_shift": 0.01236701871740357, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1056, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307467 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1084, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307591 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 4009872, + "mad_ns": 20244, + "iqr_ns": 137265.5, + "min_ns": 3946457, + "max_ns": 4190714, + "n": 5 + }, + "b": { + "median_ns": 3993843, + "mad_ns": 18031, + "iqr_ns": 99076.0, + "min_ns": 3860770, + "max_ns": 4011874, + "n": 5 + }, + "raw_a_ns": [ + 3989628, + 4190714, + 3946457, + 4019902, + 4009872 + ], + "raw_b_ns": [ + 4011874, + 3860770, + 3993843, + 3994258, + 3947210 + ], + "absolute_median_shift_ns": 16029, + "relative_median_shift": 0.003997384455164654, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1084, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307591 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1112, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307717 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 3970597, + "mad_ns": 67039, + "iqr_ns": 119079.0, + "min_ns": 3816196, + "max_ns": 4149385, + "n": 15 + }, + "b": { + "median_ns": 4181643, + "mad_ns": 121959, + "iqr_ns": 260242.0, + "min_ns": 4000357, + "max_ns": 4497481, + "n": 15 + }, + "raw_a_ns": [ + 4003814, + 4056701, + 4149385, + 4074953, + 3870528, + 4006156, + 3903558, + 3930764, + 3887699, + 4000127, + 3931448, + 3816196, + 3970597, + 3895411, + 4014490 + ], + "raw_b_ns": [ + 4016794, + 4059684, + 4000357, + 4068674, + 4002134, + 4114837, + 4022713, + 4225978, + 4437331, + 4329543, + 4181643, + 4497481, + 4282955, + 4274328, + 4273885 + ], + "absolute_median_shift_ns": 211046, + "relative_median_shift": 0.05315220859734695, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1112, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 307723 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1180, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 308020 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 4075799, + "mad_ns": 112014, + "iqr_ns": 232079.0, + "min_ns": 3918012, + "max_ns": 4331355, + "n": 15 + }, + "b": { + "median_ns": 4054062, + "mad_ns": 87823, + "iqr_ns": 257795.0, + "min_ns": 3939748, + "max_ns": 4535952, + "n": 15 + }, + "raw_a_ns": [ + 4187813, + 4013771, + 4195045, + 3927714, + 3918012, + 4118126, + 4193397, + 4043112, + 4099786, + 4331355, + 4075799, + 3955734, + 3933087, + 4160041, + 3985415 + ], + "raw_b_ns": [ + 4104775, + 3939748, + 4008698, + 3993835, + 4155101, + 4054062, + 4007125, + 4037757, + 4529250, + 4264920, + 4166443, + 4535952, + 4331348, + 3966239, + 4048627 + ], + "absolute_median_shift_ns": 21737, + "relative_median_shift": 0.005333187431470492, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1180, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 308020 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1248, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 308341 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 4247217, + "mad_ns": 195087, + "iqr_ns": 304914.0, + "min_ns": 3933124, + "max_ns": 4619493, + "n": 15 + }, + "b": { + "median_ns": 4092346, + "mad_ns": 63176, + "iqr_ns": 143443.0, + "min_ns": 3957616, + "max_ns": 5348866, + "n": 15 + }, + "raw_a_ns": [ + 4257730, + 4247217, + 4052130, + 4009189, + 4254936, + 4006138, + 3960502, + 3991065, + 3933124, + 4447376, + 4327799, + 4280193, + 4619493, + 4183010, + 4311052 + ], + "raw_b_ns": [ + 4135677, + 4048314, + 4155522, + 4092346, + 4738715, + 4103600, + 4012079, + 3977029, + 5348866, + 4033335, + 3988833, + 3957616, + 4215379, + 4066389, + 4142941 + ], + "absolute_median_shift_ns": 154871, + "relative_median_shift": 0.036464112853193044, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1248, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 308343 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1316, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 308714 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 4066559, + "mad_ns": 103922, + "iqr_ns": 223867.0, + "min_ns": 3910327, + "max_ns": 4252639, + "n": 15 + }, + "b": { + "median_ns": 4091474, + "mad_ns": 65614, + "iqr_ns": 112363.0, + "min_ns": 3935212, + "max_ns": 4537091, + "n": 15 + }, + "raw_a_ns": [ + 4056480, + 3971444, + 4070040, + 3978616, + 4193183, + 3962637, + 4162107, + 3952598, + 4178818, + 4066559, + 4252639, + 3964669, + 4188536, + 3910327, + 4249079 + ], + "raw_b_ns": [ + 4085609, + 4103259, + 4069857, + 4295387, + 3935212, + 4537091, + 4319613, + 4066368, + 4122487, + 4091474, + 4083021, + 4165912, + 4025860, + 4018432, + 4178731 + ], + "absolute_median_shift_ns": 24915, + "relative_median_shift": 0.006126801553844418, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1316, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 308714 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1384, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309175 + } + }, + { + "target_ms": 4, + "iterations": 1838383, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 4044928, + "mad_ns": 65700, + "iqr_ns": 146834.0, + "min_ns": 3821989, + "max_ns": 4133018, + "n": 15 + }, + "b": { + "median_ns": 3973607, + "mad_ns": 27445, + "iqr_ns": 90868.0, + "min_ns": 3871694, + "max_ns": 4146893, + "n": 15 + }, + "raw_a_ns": [ + 4133018, + 3942417, + 3979228, + 4107598, + 4059009, + 3960764, + 4112588, + 4059925, + 4120912, + 4057650, + 4021918, + 3821989, + 4044928, + 3994532, + 3926141 + ], + "raw_b_ns": [ + 3955586, + 4018386, + 4146893, + 4000920, + 3895944, + 3961118, + 4001052, + 4016523, + 3871694, + 3904548, + 3967500, + 3993560, + 3973607, + 3991724, + 3910184 + ], + "absolute_median_shift_ns": 71321, + "relative_median_shift": 0.017632205072624283, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1384, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309175 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1452, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309513 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 7830504, + "mad_ns": 20511, + "iqr_ns": 91169.0, + "min_ns": 7809993, + "max_ns": 7928505, + "n": 5 + }, + "b": { + "median_ns": 7867983, + "mad_ns": 69917, + "iqr_ns": 236826.0, + "min_ns": 7789683, + "max_ns": 8125022, + "n": 5 + }, + "raw_a_ns": [ + 7928505, + 7885594, + 7809993, + 7830504, + 7821768 + ], + "raw_b_ns": [ + 7789683, + 7867983, + 7799587, + 7937900, + 8125022 + ], + "absolute_median_shift_ns": 37479, + "relative_median_shift": 0.004786281955797481, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1452, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309513 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1480, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309678 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 7880408, + "mad_ns": 85785, + "iqr_ns": 204406.0, + "min_ns": 7776277, + "max_ns": 8056046, + "n": 5 + }, + "b": { + "median_ns": 7905422, + "mad_ns": 92022, + "iqr_ns": 256071.0, + "min_ns": 7813400, + "max_ns": 8108441, + "n": 5 + }, + "raw_a_ns": [ + 8056046, + 7837150, + 7966193, + 7880408, + 7776277 + ], + "raw_b_ns": [ + 7856009, + 7905422, + 7813400, + 8108441, + 8073110 + ], + "absolute_median_shift_ns": 25014, + "relative_median_shift": 0.003174201132733229, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1480, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309678 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1508, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309861 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 7905021, + "mad_ns": 97404, + "iqr_ns": 202027.5, + "min_ns": 7755653, + "max_ns": 8002425, + "n": 5 + }, + "b": { + "median_ns": 7960065, + "mad_ns": 77538, + "iqr_ns": 477645.0, + "min_ns": 7757728, + "max_ns": 8631547, + "n": 5 + }, + "raw_a_ns": [ + 7919300, + 7905021, + 7762017, + 8002425, + 7755653 + ], + "raw_b_ns": [ + 7960065, + 8631547, + 7963998, + 7757728, + 7882527 + ], + "absolute_median_shift_ns": 55044, + "relative_median_shift": 0.0069631693578043625, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1508, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 309861 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1536, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310008 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 7884370, + "mad_ns": 13699, + "iqr_ns": 198417.5, + "min_ns": 7778091, + "max_ns": 8153685, + "n": 5 + }, + "b": { + "median_ns": 7936854, + "mad_ns": 108172, + "iqr_ns": 319366.0, + "min_ns": 7828682, + "max_ns": 8191597, + "n": 5 + }, + "raw_a_ns": [ + 7778091, + 7870671, + 7891912, + 7884370, + 8153685 + ], + "raw_b_ns": [ + 7936854, + 7828682, + 8191597, + 8163219, + 7887402 + ], + "absolute_median_shift_ns": 52484, + "relative_median_shift": 0.006656714487016718, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1536, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310008 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1564, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310165 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 8257941, + "mad_ns": 91568, + "iqr_ns": 950579.5, + "min_ns": 7996312, + "max_ns": 9726946, + "n": 5 + }, + "b": { + "median_ns": 8316171, + "mad_ns": 79484, + "iqr_ns": 292393.0, + "min_ns": 8028122, + "max_ns": 8395655, + "n": 5 + }, + "raw_a_ns": [ + 8257941, + 7996312, + 9726946, + 8166373, + 8336898 + ], + "raw_b_ns": [ + 8028122, + 8316171, + 8106704, + 8395655, + 8323957 + ], + "absolute_median_shift_ns": 58230, + "relative_median_shift": 0.007051394530428348, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1564, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310165 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1592, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310350 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 8263922, + "mad_ns": 137750, + "iqr_ns": 291601.0, + "min_ns": 8082310, + "max_ns": 8690698, + "n": 15 + }, + "b": { + "median_ns": 8060507, + "mad_ns": 121524, + "iqr_ns": 243624.0, + "min_ns": 7907725, + "max_ns": 8268710, + "n": 15 + }, + "raw_a_ns": [ + 8401672, + 8690698, + 8477299, + 8595414, + 8082310, + 8294263, + 8263922, + 8097819, + 8240164, + 8094957, + 8422063, + 8186031, + 8130462, + 8224029, + 8358880 + ], + "raw_b_ns": [ + 8268710, + 8143429, + 8060507, + 8114173, + 7944786, + 8267138, + 8192744, + 7938407, + 8182031, + 8041786, + 7949073, + 7907725, + 8083705, + 7908275, + 7930664 + ], + "absolute_median_shift_ns": 203415, + "relative_median_shift": 0.0246148257449671, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1592, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310352 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1660, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310841 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 8005860, + "mad_ns": 78716, + "iqr_ns": 219315.0, + "min_ns": 7855928, + "max_ns": 8349981, + "n": 15 + }, + "b": { + "median_ns": 7914258, + "mad_ns": 69550, + "iqr_ns": 176179.0, + "min_ns": 7808948, + "max_ns": 8116566, + "n": 15 + }, + "raw_a_ns": [ + 8220166, + 7927144, + 7969218, + 8149322, + 8044906, + 7945450, + 7903617, + 8005860, + 8349981, + 8056993, + 8008413, + 7875943, + 7855928, + 7930281, + 8146459 + ], + "raw_b_ns": [ + 7914258, + 7880878, + 8116566, + 8086666, + 7874608, + 7844708, + 7840661, + 8020887, + 7808948, + 7957885, + 8096032, + 7960554, + 7873019, + 7836248, + 7943664 + ], + "absolute_median_shift_ns": 91602, + "relative_median_shift": 0.011441868831081232, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1660, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 310841 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1728, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 311239 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 7963969, + "mad_ns": 36214, + "iqr_ns": 355580.0, + "min_ns": 7757914, + "max_ns": 8324698, + "n": 15 + }, + "b": { + "median_ns": 7884701, + "mad_ns": 38397, + "iqr_ns": 77636.0, + "min_ns": 7826829, + "max_ns": 8053840, + "n": 15 + }, + "raw_a_ns": [ + 7929660, + 8279985, + 7927755, + 7924413, + 8306989, + 7949586, + 8291005, + 8285240, + 8324698, + 7963969, + 7950996, + 7978193, + 7757914, + 7990919, + 7955233 + ], + "raw_b_ns": [ + 7898042, + 7902604, + 7934354, + 7849337, + 7844081, + 7884701, + 7923098, + 7845462, + 8053840, + 7845396, + 7938451, + 7870389, + 7826829, + 7894829, + 7865672 + ], + "absolute_median_shift_ns": 79268, + "relative_median_shift": 0.009953328547612378, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1728, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 311239 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1796, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 311660 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 8087453, + "mad_ns": 128895, + "iqr_ns": 294449.0, + "min_ns": 7869379, + "max_ns": 9367106, + "n": 15 + }, + "b": { + "median_ns": 8090725, + "mad_ns": 91473, + "iqr_ns": 262519.0, + "min_ns": 7886670, + "max_ns": 8370886, + "n": 15 + }, + "raw_a_ns": [ + 8253007, + 8348562, + 9367106, + 8035793, + 7948060, + 7966010, + 8098765, + 7948412, + 8056228, + 7958558, + 7869379, + 8461245, + 8092687, + 8109064, + 8087453 + ], + "raw_b_ns": [ + 8039797, + 8004152, + 8051961, + 8261771, + 8305923, + 8090725, + 8098136, + 8114861, + 8160806, + 7923465, + 7986258, + 8370886, + 7886670, + 7999252, + 8290505 + ], + "absolute_median_shift_ns": 3272, + "relative_median_shift": 0.00040457731253585027, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1796, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 311660 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1864, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 312112 + } + }, + { + "target_ms": 8, + "iterations": 4594589, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 7838873, + "mad_ns": 72497, + "iqr_ns": 229025.0, + "min_ns": 7741020, + "max_ns": 8083922, + "n": 15 + }, + "b": { + "median_ns": 7885718, + "mad_ns": 60854, + "iqr_ns": 125306.0, + "min_ns": 7760885, + "max_ns": 8121136, + "n": 15 + }, + "raw_a_ns": [ + 7876326, + 8078165, + 7931508, + 7831138, + 7892486, + 7766376, + 7838873, + 7761401, + 8005599, + 8083922, + 7776574, + 7741020, + 7821233, + 8040584, + 7800099 + ], + "raw_b_ns": [ + 7959828, + 7794409, + 7872145, + 7854611, + 8028894, + 7893670, + 7862384, + 8121136, + 7834522, + 8008974, + 7760885, + 7908072, + 7820792, + 7946572, + 7885718 + ], + "absolute_median_shift_ns": 46845, + "relative_median_shift": 0.005975986599094028, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1864, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 312112 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1932, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 312563 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 15968266, + "mad_ns": 76515, + "iqr_ns": 782395.5, + "min_ns": 15835867, + "max_ns": 17255298, + "n": 5 + }, + "b": { + "median_ns": 15942303, + "mad_ns": 55001, + "iqr_ns": 164114.5, + "min_ns": 15887302, + "max_ns": 16103500, + "n": 5 + }, + "raw_a_ns": [ + 17255298, + 15968266, + 16037111, + 15835867, + 15891751 + ], + "raw_b_ns": [ + 15887302, + 15940765, + 15942303, + 16052796, + 16103500 + ], + "absolute_median_shift_ns": 25963, + "relative_median_shift": 0.0016259122937957071, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1932, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 312565 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1960, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 312814 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 15818136, + "mad_ns": 46419, + "iqr_ns": 193905.5, + "min_ns": 15720701, + "max_ns": 16058190, + "n": 5 + }, + "b": { + "median_ns": 16013052, + "mad_ns": 151946, + "iqr_ns": 321617.0, + "min_ns": 15798757, + "max_ns": 16179771, + "n": 5 + }, + "raw_a_ns": [ + 16058190, + 15864555, + 15814233, + 15818136, + 15720701 + ], + "raw_b_ns": [ + 15798757, + 16013052, + 15861106, + 16123326, + 16179771 + ], + "absolute_median_shift_ns": 194916, + "relative_median_shift": 0.012322311554281743, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1960, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 312814 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1988, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313095 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 15765067, + "mad_ns": 12415, + "iqr_ns": 146425.5, + "min_ns": 15744474, + "max_ns": 16024781, + "n": 5 + }, + "b": { + "median_ns": 15906996, + "mad_ns": 32805, + "iqr_ns": 142515.5, + "min_ns": 15769696, + "max_ns": 15939801, + "n": 5 + }, + "raw_a_ns": [ + 15752652, + 15765196, + 15744474, + 16024781, + 15765067 + ], + "raw_b_ns": [ + 15937466, + 15822540, + 15906996, + 15939801, + 15769696 + ], + "absolute_median_shift_ns": 141929, + "relative_median_shift": 0.009002752731720074, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 1988, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313095 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 2016, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313306 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 15994171, + "mad_ns": 46379, + "iqr_ns": 171055.5, + "min_ns": 15770151, + "max_ns": 16062082, + "n": 5 + }, + "b": { + "median_ns": 15986890, + "mad_ns": 117475, + "iqr_ns": 244191.0, + "min_ns": 15856906, + "max_ns": 16123813, + "n": 5 + }, + "raw_a_ns": [ + 15990370, + 15770151, + 16062082, + 16040550, + 15994171 + ], + "raw_b_ns": [ + 15856906, + 15986890, + 16104365, + 15882890, + 16123813 + ], + "absolute_median_shift_ns": 7281, + "relative_median_shift": 0.000455228345376575, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 2016, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313306 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 2044, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313618 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 15871057, + "mad_ns": 26959, + "iqr_ns": 107141.0, + "min_ns": 15844098, + "max_ns": 15958479, + "n": 5 + }, + "b": { + "median_ns": 15745850, + "mad_ns": 44028, + "iqr_ns": 261911.0, + "min_ns": 15701822, + "max_ns": 16152431, + "n": 5 + }, + "raw_a_ns": [ + 15844098, + 15853014, + 15958479, + 15952915, + 15871057 + ], + "raw_b_ns": [ + 15738941, + 15812154, + 16152431, + 15701822, + 15745850 + ], + "absolute_median_shift_ns": 125207, + "relative_median_shift": 0.007889014575399736, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 2044, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313618 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 2072, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313874 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 15757831, + "mad_ns": 78636, + "iqr_ns": 177284.0, + "min_ns": 15623836, + "max_ns": 16677156, + "n": 15 + }, + "b": { + "median_ns": 15723436, + "mad_ns": 91585, + "iqr_ns": 283139.0, + "min_ns": 15597886, + "max_ns": 16147675, + "n": 15 + }, + "raw_a_ns": [ + 15960592, + 15757831, + 15868215, + 15779491, + 15716839, + 15679195, + 16677156, + 15730058, + 15775832, + 15856479, + 15623836, + 15686113, + 15666314, + 15668614, + 15823884 + ], + "raw_b_ns": [ + 15872158, + 15688107, + 15959310, + 15913747, + 15640828, + 15651671, + 15631851, + 15697685, + 15597886, + 15723436, + 15782297, + 16147675, + 15934810, + 15659112, + 16024620 + ], + "absolute_median_shift_ns": 34395, + "relative_median_shift": 0.002182724259449159, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.40869140625, + 0.1513671875, + 0.04736328125 + ], + "voluntary_ctxt_switches": 2072, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 313876 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2140, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 314459 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 15803205, + "mad_ns": 103300, + "iqr_ns": 187234.0, + "min_ns": 15668417, + "max_ns": 17516919, + "n": 15 + }, + "b": { + "median_ns": 16124013, + "mad_ns": 308366, + "iqr_ns": 792567.0, + "min_ns": 15754896, + "max_ns": 18502396, + "n": 15 + }, + "raw_a_ns": [ + 15942364, + 15809530, + 15734267, + 15762222, + 15699905, + 15668417, + 15757822, + 15940011, + 15752777, + 17516919, + 16030337, + 15803205, + 15925172, + 15766413, + 15920639 + ], + "raw_b_ns": [ + 15817288, + 15912360, + 15815647, + 15754896, + 15781550, + 15812868, + 17131841, + 16314420, + 16124013, + 16091951, + 18502396, + 16608214, + 16150441, + 17639758, + 16208560 + ], + "absolute_median_shift_ns": 320808, + "relative_median_shift": 0.020300185943294413, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2140, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 314459 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2208, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 315095 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 15984200, + "mad_ns": 250386, + "iqr_ns": 635426.0, + "min_ns": 15720306, + "max_ns": 16916813, + "n": 15 + }, + "b": { + "median_ns": 16077295, + "mad_ns": 131718, + "iqr_ns": 295577.0, + "min_ns": 15807559, + "max_ns": 17069359, + "n": 15 + }, + "raw_a_ns": [ + 16916813, + 15720306, + 16085667, + 15853385, + 16235575, + 16288371, + 16901541, + 15739203, + 15984200, + 15733814, + 16436033, + 15800607, + 15873839, + 15961255, + 16438919 + ], + "raw_b_ns": [ + 15915297, + 15807559, + 15961375, + 16054529, + 16209013, + 16685357, + 16267731, + 16021246, + 17069359, + 16256952, + 16077796, + 16077295, + 15930333, + 16167510, + 16034625 + ], + "absolute_median_shift_ns": 93095, + "relative_median_shift": 0.005824188886525444, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2208, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 315095 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2276, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 315678 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 15906887, + "mad_ns": 139899, + "iqr_ns": 390606.0, + "min_ns": 15647186, + "max_ns": 17100897, + "n": 15 + }, + "b": { + "median_ns": 16212271, + "mad_ns": 147915, + "iqr_ns": 328925.0, + "min_ns": 15785067, + "max_ns": 17200697, + "n": 15 + }, + "raw_a_ns": [ + 15906887, + 16229006, + 16181633, + 17100897, + 15871249, + 15758932, + 15647186, + 15735940, + 15818876, + 15904425, + 16006102, + 15766988, + 16157594, + 15919621, + 15927461 + ], + "raw_b_ns": [ + 15785067, + 16640893, + 15998139, + 16310333, + 16136558, + 16212271, + 16120610, + 16393281, + 16330281, + 16064356, + 16196730, + 16251232, + 17200697, + 15832616, + 16418985 + ], + "absolute_median_shift_ns": 305384, + "relative_median_shift": 0.01919822527185866, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2276, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 315678 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2344, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 316323 + } + }, + { + "target_ms": 16, + "iterations": 10107001, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 15809419, + "mad_ns": 119647, + "iqr_ns": 331098.0, + "min_ns": 15664195, + "max_ns": 16420049, + "n": 15 + }, + "b": { + "median_ns": 15886864, + "mad_ns": 155673, + "iqr_ns": 317804.0, + "min_ns": 15682107, + "max_ns": 16353117, + "n": 15 + }, + "raw_a_ns": [ + 15710283, + 16047330, + 15708039, + 15912494, + 16420049, + 15992372, + 15762397, + 15668401, + 15689772, + 16043567, + 15725038, + 15816101, + 15664195, + 15809419, + 16039137 + ], + "raw_b_ns": [ + 15846162, + 15867461, + 16185798, + 15929669, + 15695224, + 15745565, + 16039787, + 15682107, + 15682356, + 15773500, + 16251989, + 16063369, + 15886864, + 16042537, + 16353117 + ], + "absolute_median_shift_ns": 77445, + "relative_median_shift": 0.004898661993840508, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2344, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 316323 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2412, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 316974 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 32433311, + "mad_ns": 400706, + "iqr_ns": 3063756.5, + "min_ns": 32032605, + "max_ns": 37122942, + "n": 5 + }, + "b": { + "median_ns": 31972528, + "mad_ns": 270736, + "iqr_ns": 865451.0, + "min_ns": 31701792, + "max_ns": 32684575, + "n": 5 + }, + "raw_a_ns": [ + 32433311, + 37122942, + 32032605, + 33101930, + 32064754 + ], + "raw_b_ns": [ + 32681096, + 31932977, + 31701792, + 31972528, + 32684575 + ], + "absolute_median_shift_ns": 460783, + "relative_median_shift": 0.01420709097507806, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2412, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 316975 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2440, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 317333 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 33422489, + "mad_ns": 935523, + "iqr_ns": 14393323.0, + "min_ns": 32486966, + "max_ns": 56590785, + "n": 5 + }, + "b": { + "median_ns": 31820091, + "mad_ns": 25759, + "iqr_ns": 103039.0, + "min_ns": 31691930, + "max_ns": 31850653, + "n": 5 + }, + "raw_a_ns": [ + 32486966, + 33422489, + 56590785, + 32713418, + 37396245 + ], + "raw_b_ns": [ + 31850653, + 31691930, + 31845850, + 31798495, + 31820091 + ], + "absolute_median_shift_ns": 1602398, + "relative_median_shift": 0.04794370640678496, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2440, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 317333 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2468, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 317833 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 31785340, + "mad_ns": 37227, + "iqr_ns": 284783.0, + "min_ns": 31658229, + "max_ns": 32164968, + "n": 5 + }, + "b": { + "median_ns": 31821547, + "mad_ns": 243591, + "iqr_ns": 748181.5, + "min_ns": 31411009, + "max_ns": 32518673, + "n": 5 + }, + "raw_a_ns": [ + 32164968, + 31810940, + 31748113, + 31658229, + 31785340 + ], + "raw_b_ns": [ + 32065138, + 31821547, + 32518673, + 31676439, + 31411009 + ], + "absolute_median_shift_ns": 36207, + "relative_median_shift": 0.0011391100425542089, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2468, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 317833 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2496, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 318212 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 32296533, + "mad_ns": 96897, + "iqr_ns": 511353.0, + "min_ns": 31816169, + "max_ns": 32393430, + "n": 5 + }, + "b": { + "median_ns": 31823574, + "mad_ns": 115304, + "iqr_ns": 435680.5, + "min_ns": 31414744, + "max_ns": 32070176, + "n": 5 + }, + "raw_a_ns": [ + 31816169, + 32393430, + 32296533, + 31892911, + 32338356 + ], + "raw_b_ns": [ + 31708270, + 31924199, + 31823574, + 32070176, + 31414744 + ], + "absolute_median_shift_ns": 472959, + "relative_median_shift": 0.014644265376720157, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2496, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 318212 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2524, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 318574 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 31588549, + "mad_ns": 39536, + "iqr_ns": 376916.5, + "min_ns": 31335072, + "max_ns": 32035617, + "n": 5 + }, + "b": { + "median_ns": 31627163, + "mad_ns": 57204, + "iqr_ns": 257133.0, + "min_ns": 31541557, + "max_ns": 31967974, + "n": 5 + }, + "raw_a_ns": [ + 32035617, + 31549013, + 31335072, + 31602301, + 31588549 + ], + "raw_b_ns": [ + 31541557, + 31627163, + 31569959, + 31657808, + 31967974 + ], + "absolute_median_shift_ns": 38614, + "relative_median_shift": 0.0012224049923913883, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2524, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 318574 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2552, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 319109 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 31834479, + "mad_ns": 246992, + "iqr_ns": 957739.0, + "min_ns": 31468253, + "max_ns": 33050814, + "n": 15 + }, + "b": { + "median_ns": 31885023, + "mad_ns": 264760, + "iqr_ns": 1014391.0, + "min_ns": 31424908, + "max_ns": 32849406, + "n": 15 + }, + "raw_a_ns": [ + 31814965, + 31620768, + 31587487, + 31586196, + 31723685, + 31850479, + 31866803, + 32161275, + 31706885, + 31468253, + 31834479, + 32578507, + 33050814, + 32642755, + 33023415 + ], + "raw_b_ns": [ + 31424908, + 31557111, + 31950768, + 31774454, + 31465203, + 31647546, + 31825284, + 32149783, + 32849406, + 32713412, + 32783502, + 31885023, + 32048139, + 31836639, + 32661937 + ], + "absolute_median_shift_ns": 50544, + "relative_median_shift": 0.0015877124924833857, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.4560546875, + 0.16552734375, + 0.052734375 + ], + "voluntary_ctxt_switches": 2552, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 319111 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2620, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 320076 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 31830781, + "mad_ns": 129032, + "iqr_ns": 472719.0, + "min_ns": 31500995, + "max_ns": 32362649, + "n": 15 + }, + "b": { + "median_ns": 31952460, + "mad_ns": 300188, + "iqr_ns": 753569.0, + "min_ns": 31624385, + "max_ns": 34106387, + "n": 15 + }, + "raw_a_ns": [ + 31915099, + 32362649, + 32266533, + 31615282, + 31701749, + 31830781, + 31917456, + 31791627, + 32268121, + 31623530, + 31757915, + 31500995, + 32174468, + 31792582, + 31856608 + ], + "raw_b_ns": [ + 32116866, + 31817500, + 34106387, + 32976825, + 33092952, + 32335326, + 31808154, + 32025277, + 31708319, + 31647863, + 31785184, + 31652272, + 31952460, + 32461888, + 31624385 + ], + "absolute_median_shift_ns": 121679, + "relative_median_shift": 0.0038226834585051495, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2620, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 320076 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2688, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 321065 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 31771175, + "mad_ns": 186628, + "iqr_ns": 385181.0, + "min_ns": 31545729, + "max_ns": 32289383, + "n": 15 + }, + "b": { + "median_ns": 31876620, + "mad_ns": 177931, + "iqr_ns": 376644.0, + "min_ns": 31433719, + "max_ns": 32922832, + "n": 15 + }, + "raw_a_ns": [ + 31584547, + 31609903, + 31771175, + 31751918, + 31996785, + 31926722, + 31989265, + 31993794, + 31712625, + 31545729, + 31608613, + 32091716, + 31806219, + 31547528, + 32289383 + ], + "raw_b_ns": [ + 32054551, + 31717829, + 32414940, + 31790731, + 32359885, + 31711976, + 31876620, + 31677907, + 31433719, + 32042152, + 31455749, + 31958127, + 31597820, + 32026242, + 32922832 + ], + "absolute_median_shift_ns": 105445, + "relative_median_shift": 0.003318888898506272, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2688, + "nonvoluntary_ctxt_switches": 10, + "system_ctxt": 321065 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2756, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 322223 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 32104502, + "mad_ns": 426949, + "iqr_ns": 933446.0, + "min_ns": 31544188, + "max_ns": 35497908, + "n": 15 + }, + "b": { + "median_ns": 32308758, + "mad_ns": 577212, + "iqr_ns": 1339654.0, + "min_ns": 31695217, + "max_ns": 33492467, + "n": 15 + }, + "raw_a_ns": [ + 32610999, + 35497908, + 32276274, + 32217708, + 31677553, + 31979743, + 32403597, + 32104502, + 31544188, + 31689310, + 31675559, + 31626328, + 31866931, + 32620434, + 33194330 + ], + "raw_b_ns": [ + 33076331, + 32896909, + 33468903, + 33492467, + 32507055, + 32308758, + 32745592, + 31731546, + 31724212, + 31895085, + 33242726, + 31736677, + 31944883, + 31878956, + 31695217 + ], + "absolute_median_shift_ns": 204256, + "relative_median_shift": 0.0063622229679812506, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2756, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 322223 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2824, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 323187 + } + }, + { + "target_ms": 32, + "iterations": 21131826, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 31742141, + "mad_ns": 115795, + "iqr_ns": 297136.0, + "min_ns": 31378442, + "max_ns": 32798193, + "n": 15 + }, + "b": { + "median_ns": 31659736, + "mad_ns": 89128, + "iqr_ns": 196158.0, + "min_ns": 31555133, + "max_ns": 32977719, + "n": 15 + }, + "raw_a_ns": [ + 31742141, + 31640188, + 32347301, + 32798193, + 31776728, + 31937324, + 31512114, + 31779436, + 31664534, + 31378442, + 31702520, + 31859206, + 32119544, + 31664344, + 31626346 + ], + "raw_b_ns": [ + 31659736, + 31562492, + 31728850, + 31593898, + 31711142, + 31766766, + 31555133, + 31852756, + 31570608, + 31791677, + 31564357, + 31599326, + 31744292, + 31572626, + 32977719 + ], + "absolute_median_shift_ns": 82405, + "relative_median_shift": 0.0025960756711401415, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5, + 0.1796875, + 0.05810546875 + ], + "voluntary_ctxt_switches": 2824, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 323187 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2892, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 324007 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 64759573, + "mad_ns": 593756, + "iqr_ns": 1368309.5, + "min_ns": 63522436, + "max_ns": 65353329, + "n": 5 + }, + "b": { + "median_ns": 64362236, + "mad_ns": 422144, + "iqr_ns": 870563.5, + "min_ns": 63876493, + "max_ns": 65107541, + "n": 5 + }, + "raw_a_ns": [ + 63522436, + 64759573, + 63935837, + 64841563, + 65353329 + ], + "raw_b_ns": [ + 64450171, + 65107541, + 63940092, + 63876493, + 64362236 + ], + "absolute_median_shift_ns": 397337, + "relative_median_shift": 0.0061355716474535745, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2892, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 324009 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2920, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 324511 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 66808416, + "mad_ns": 580838, + "iqr_ns": 2065125.0, + "min_ns": 64878104, + "max_ns": 67389254, + "n": 5 + }, + "b": { + "median_ns": 63200115, + "mad_ns": 97823, + "iqr_ns": 700689.5, + "min_ns": 63102292, + "max_ns": 64199457, + "n": 5 + }, + "raw_a_ns": [ + 67389254, + 65272317, + 66891417, + 64878104, + 66808416 + ], + "raw_b_ns": [ + 63199972, + 63102292, + 63504186, + 63200115, + 64199457 + ], + "absolute_median_shift_ns": 3608301, + "relative_median_shift": 0.05400967746339024, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2920, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 324511 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2948, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 325025 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 63891568, + "mad_ns": 390342, + "iqr_ns": 1710784.5, + "min_ns": 63501226, + "max_ns": 66180764, + "n": 5 + }, + "b": { + "median_ns": 63888896, + "mad_ns": 108831, + "iqr_ns": 567862.5, + "min_ns": 63180197, + "max_ns": 64129848, + "n": 5 + }, + "raw_a_ns": [ + 66180764, + 64308093, + 63566062, + 63501226, + 63891568 + ], + "raw_b_ns": [ + 63780065, + 63180197, + 63966139, + 64129848, + 63888896 + ], + "absolute_median_shift_ns": 2672, + "relative_median_shift": 4.182085498355589e-05, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2948, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 325025 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2976, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 325540 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 63946266, + "mad_ns": 621917, + "iqr_ns": 1687740.5, + "min_ns": 63324349, + "max_ns": 65446836, + "n": 5 + }, + "b": { + "median_ns": 63487508, + "mad_ns": 229008, + "iqr_ns": 675604.0, + "min_ns": 63257059, + "max_ns": 64284711, + "n": 5 + }, + "raw_a_ns": [ + 63324349, + 65446836, + 63946266, + 64795088, + 63542094 + ], + "raw_b_ns": [ + 64284711, + 63257059, + 63582056, + 63258500, + 63487508 + ], + "absolute_median_shift_ns": 458758, + "relative_median_shift": 0.0071741170938737844, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 2976, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 325540 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 3004, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 326038 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 63513202, + "mad_ns": 430138, + "iqr_ns": 1358853.0, + "min_ns": 63002619, + "max_ns": 65169008, + "n": 5 + }, + "b": { + "median_ns": 64552599, + "mad_ns": 245319, + "iqr_ns": 641710.5, + "min_ns": 63991515, + "max_ns": 64831098, + "n": 5 + }, + "raw_a_ns": [ + 63513202, + 63002619, + 63392023, + 65169008, + 63943340 + ], + "raw_b_ns": [ + 64307280, + 64831098, + 63991515, + 64552599, + 64751118 + ], + "absolute_median_shift_ns": 1039397, + "relative_median_shift": 0.01636505430792168, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 3004, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 326038 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 3032, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 326783 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 63805318, + "mad_ns": 259570, + "iqr_ns": 553369.0, + "min_ns": 63284232, + "max_ns": 64768701, + "n": 15 + }, + "b": { + "median_ns": 63653326, + "mad_ns": 241434, + "iqr_ns": 589114.0, + "min_ns": 63145814, + "max_ns": 64329271, + "n": 15 + }, + "raw_a_ns": [ + 64768701, + 63284232, + 63480443, + 63491431, + 63568150, + 64106001, + 63745656, + 64099117, + 63826664, + 64717978, + 63745132, + 63948157, + 63805318, + 64025004, + 63545748 + ], + "raw_b_ns": [ + 63868366, + 63780759, + 63295446, + 63271831, + 63291317, + 64193825, + 63471830, + 64329271, + 63884560, + 63470069, + 63894760, + 63653326, + 63878647, + 63370865, + 63145814 + ], + "absolute_median_shift_ns": 151992, + "relative_median_shift": 0.0023821211893340927, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5400390625, + 0.193359375, + 0.0634765625 + ], + "voluntary_ctxt_switches": 3032, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 326783 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5771484375, + 0.20703125, + 0.06884765625 + ], + "voluntary_ctxt_switches": 3100, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 327916 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 63414097, + "mad_ns": 103560, + "iqr_ns": 450505.0, + "min_ns": 62936189, + "max_ns": 64596709, + "n": 15 + }, + "b": { + "median_ns": 63056964, + "mad_ns": 164716, + "iqr_ns": 384646.0, + "min_ns": 62892248, + "max_ns": 63670302, + "n": 15 + }, + "raw_a_ns": [ + 63310537, + 64596709, + 63445532, + 63739371, + 63414097, + 63008536, + 63417961, + 63422610, + 62974866, + 63483473, + 63473854, + 63330226, + 63023349, + 63246180, + 62936189 + ], + "raw_b_ns": [ + 63555239, + 63046063, + 62954968, + 62892248, + 63010005, + 63047356, + 62902459, + 63386930, + 63010327, + 63670302, + 63356311, + 63322926, + 63056964, + 63394651, + 63509067 + ], + "absolute_median_shift_ns": 357133, + "relative_median_shift": 0.005631760395484304, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5771484375, + 0.20703125, + 0.06884765625 + ], + "voluntary_ctxt_switches": 3100, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 327916 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5771484375, + 0.20703125, + 0.06884765625 + ], + "voluntary_ctxt_switches": 3168, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 329581 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 63786753, + "mad_ns": 367477, + "iqr_ns": 742161.0, + "min_ns": 62931021, + "max_ns": 66666126, + "n": 15 + }, + "b": { + "median_ns": 63863864, + "mad_ns": 855918, + "iqr_ns": 2013673.0, + "min_ns": 63007946, + "max_ns": 65957057, + "n": 15 + }, + "raw_a_ns": [ + 63805617, + 63368061, + 63991652, + 62931021, + 64124742, + 63432843, + 64154230, + 64278346, + 66666126, + 65092211, + 63321709, + 63412069, + 63786753, + 63436709, + 63654624 + ], + "raw_b_ns": [ + 65573306, + 65662510, + 63639691, + 64787885, + 63218729, + 63007946, + 63583996, + 63863864, + 64927547, + 63412187, + 65293003, + 65957057, + 65817161, + 63631887, + 63559633 + ], + "absolute_median_shift_ns": 77111, + "relative_median_shift": 0.0012088873688240567, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.5771484375, + 0.20703125, + 0.06884765625 + ], + "voluntary_ctxt_switches": 3168, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 329581 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.611328125, + 0.22021484375, + 0.07421875 + ], + "voluntary_ctxt_switches": 3236, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 331154 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 64306835, + "mad_ns": 726284, + "iqr_ns": 1825130.0, + "min_ns": 63296185, + "max_ns": 66044928, + "n": 15 + }, + "b": { + "median_ns": 65021541, + "mad_ns": 1287600, + "iqr_ns": 2859207.0, + "min_ns": 63251481, + "max_ns": 69261023, + "n": 15 + }, + "raw_a_ns": [ + 66044928, + 65065710, + 64780857, + 64794803, + 64306835, + 63573040, + 63296185, + 64068721, + 63774392, + 65599522, + 65941782, + 65814388, + 63809277, + 63580551, + 64016917 + ], + "raw_b_ns": [ + 63570019, + 65021541, + 63733941, + 63251481, + 64022089, + 64599486, + 63353340, + 64028077, + 66593148, + 69261023, + 65213057, + 68154354, + 66969074, + 65119608, + 65914834 + ], + "absolute_median_shift_ns": 714706, + "relative_median_shift": 0.011113997446772182, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.611328125, + 0.22021484375, + 0.07421875 + ], + "voluntary_ctxt_switches": 3236, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 331154 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.611328125, + 0.22021484375, + 0.07421875 + ], + "voluntary_ctxt_switches": 3304, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 333054 + } + }, + { + "target_ms": 64, + "iterations": 43181474, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 65007049, + "mad_ns": 823523, + "iqr_ns": 2765017.0, + "min_ns": 63761325, + "max_ns": 70340571, + "n": 15 + }, + "b": { + "median_ns": 63861225, + "mad_ns": 459282, + "iqr_ns": 1369195.0, + "min_ns": 62825083, + "max_ns": 65213362, + "n": 15 + }, + "raw_a_ns": [ + 65793201, + 64183526, + 64354594, + 64403887, + 64049743, + 64128518, + 65395675, + 66948543, + 70340571, + 65678008, + 63761325, + 64369484, + 68717440, + 68210978, + 65007049 + ], + "raw_b_ns": [ + 64486206, + 63727428, + 65213362, + 63937353, + 63957886, + 64871662, + 65064949, + 63861225, + 63420081, + 64789276, + 63515546, + 63785339, + 63401943, + 62825083, + 63263039 + ], + "absolute_median_shift_ns": 1145824, + "relative_median_shift": 0.01762615005028147, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.611328125, + 0.22021484375, + 0.07421875 + ], + "voluntary_ctxt_switches": 3304, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 333054 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.642578125, + 0.2333984375, + 0.07958984375 + ], + "voluntary_ctxt_switches": 3372, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 334710 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 5, + "session": 0, + "a": { + "median_ns": 126207369, + "mad_ns": 233091, + "iqr_ns": 801337.5, + "min_ns": 125717311, + "max_ns": 126992145, + "n": 5 + }, + "b": { + "median_ns": 126333396, + "mad_ns": 337827, + "iqr_ns": 1406634.5, + "min_ns": 125995569, + "max_ns": 127801150, + "n": 5 + }, + "raw_a_ns": [ + 126992145, + 125717311, + 126207369, + 125974278, + 126302119 + ], + "raw_b_ns": [ + 126057216, + 125995569, + 126333396, + 127064904, + 127801150 + ], + "absolute_median_shift_ns": 126027, + "relative_median_shift": 0.0009985708520712448, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.642578125, + 0.2333984375, + 0.07958984375 + ], + "voluntary_ctxt_switches": 3372, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 334712 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.642578125, + 0.2333984375, + 0.07958984375 + ], + "voluntary_ctxt_switches": 3400, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 335557 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 5, + "session": 1, + "a": { + "median_ns": 128098197, + "mad_ns": 1221054, + "iqr_ns": 2338890.0, + "min_ns": 126027096, + "max_ns": 129467792, + "n": 5 + }, + "b": { + "median_ns": 125333183, + "mad_ns": 142727, + "iqr_ns": 4401454.0, + "min_ns": 125190456, + "max_ns": 131403406, + "n": 5 + }, + "raw_a_ns": [ + 128098197, + 128082167, + 129467792, + 129319251, + 126027096 + ], + "raw_b_ns": [ + 127797952, + 125190456, + 125207994, + 125333183, + 131403406 + ], + "absolute_median_shift_ns": 2765014, + "relative_median_shift": 0.021585112552364807, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.642578125, + 0.2333984375, + 0.07958984375 + ], + "voluntary_ctxt_switches": 3400, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 335557 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.642578125, + 0.2333984375, + 0.07958984375 + ], + "voluntary_ctxt_switches": 3428, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 336558 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 5, + "session": 2, + "a": { + "median_ns": 126161632, + "mad_ns": 226526, + "iqr_ns": 2138142.0, + "min_ns": 125723325, + "max_ns": 129586414, + "n": 5 + }, + "b": { + "median_ns": 128039031, + "mad_ns": 598401, + "iqr_ns": 2042969.5, + "min_ns": 126355190, + "max_ns": 128637432, + "n": 5 + }, + "raw_a_ns": [ + 125935106, + 126348301, + 129586414, + 126161632, + 125723325 + ], + "raw_b_ns": [ + 126572170, + 128039031, + 128637432, + 128375867, + 126355190 + ], + "absolute_median_shift_ns": 1877399, + "relative_median_shift": 0.014880902935688086, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.642578125, + 0.2333984375, + 0.07958984375 + ], + "voluntary_ctxt_switches": 3428, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 336558 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.67138671875, + 0.24658203125, + 0.0849609375 + ], + "voluntary_ctxt_switches": 3456, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 337561 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 5, + "session": 3, + "a": { + "median_ns": 126311097, + "mad_ns": 771180, + "iqr_ns": 1509017.5, + "min_ns": 125539917, + "max_ns": 127478077, + "n": 5 + }, + "b": { + "median_ns": 127437494, + "mad_ns": 1503048, + "iqr_ns": 3376019.5, + "min_ns": 125914597, + "max_ns": 130185310, + "n": 5 + }, + "raw_a_ns": [ + 125539917, + 126311097, + 126150260, + 127478077, + 127230135 + ], + "raw_b_ns": [ + 127437494, + 125934446, + 130185310, + 128415772, + 125914597 + ], + "absolute_median_shift_ns": 1126397, + "relative_median_shift": 0.008917640862544325, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.67138671875, + 0.24658203125, + 0.0849609375 + ], + "voluntary_ctxt_switches": 3456, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 337561 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.67138671875, + 0.24658203125, + 0.0849609375 + ], + "voluntary_ctxt_switches": 3484, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 338560 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 5, + "session": 4, + "a": { + "median_ns": 128689774, + "mad_ns": 629698, + "iqr_ns": 1698041.0, + "min_ns": 127383205, + "max_ns": 129319472, + "n": 5 + }, + "b": { + "median_ns": 128724759, + "mad_ns": 1512566, + "iqr_ns": 4302358.5, + "min_ns": 126509500, + "max_ns": 133299048, + "n": 5 + }, + "raw_a_ns": [ + 128856890, + 127397075, + 127383205, + 129319472, + 128689774 + ], + "raw_b_ns": [ + 133299048, + 129027362, + 127212193, + 126509500, + 128724759 + ], + "absolute_median_shift_ns": 34985, + "relative_median_shift": 0.0002718553223972559, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.67138671875, + 0.24658203125, + 0.0849609375 + ], + "voluntary_ctxt_switches": 3484, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 338560 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.67138671875, + 0.24658203125, + 0.0849609375 + ], + "voluntary_ctxt_switches": 3512, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 339844 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 15, + "session": 0, + "a": { + "median_ns": 126922609, + "mad_ns": 498894, + "iqr_ns": 1133078.0, + "min_ns": 125513393, + "max_ns": 128312474, + "n": 15 + }, + "b": { + "median_ns": 125880666, + "mad_ns": 493582, + "iqr_ns": 1799815.0, + "min_ns": 125131337, + "max_ns": 130266668, + "n": 15 + }, + "raw_a_ns": [ + 125770898, + 126714628, + 126717750, + 125513393, + 126392084, + 127651719, + 126922609, + 126732115, + 127672536, + 127033671, + 126924527, + 127556793, + 127157834, + 128312474, + 126423715 + ], + "raw_b_ns": [ + 127538141, + 128055328, + 127122627, + 130266668, + 125729714, + 125880666, + 125131337, + 126848757, + 126029514, + 125577903, + 125387084, + 125475030, + 125410022, + 125751607, + 127274845 + ], + "absolute_median_shift_ns": 1041943, + "relative_median_shift": 0.008209278143659968, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.67138671875, + 0.24658203125, + 0.0849609375 + ], + "voluntary_ctxt_switches": 3512, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 339844 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.69775390625, + 0.25927734375, + 0.09033203125 + ], + "voluntary_ctxt_switches": 3580, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 344069 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 15, + "session": 1, + "a": { + "median_ns": 127249804, + "mad_ns": 786261, + "iqr_ns": 1940569.0, + "min_ns": 125062587, + "max_ns": 130048080, + "n": 15 + }, + "b": { + "median_ns": 127101022, + "mad_ns": 989751, + "iqr_ns": 3236861.0, + "min_ns": 125657601, + "max_ns": 133347347, + "n": 15 + }, + "raw_a_ns": [ + 125062587, + 127282212, + 127901580, + 126707994, + 126711197, + 129738423, + 126296989, + 126463543, + 128477810, + 128404112, + 130048080, + 126832157, + 125858221, + 127249804, + 127870101 + ], + "raw_b_ns": [ + 129366119, + 127726977, + 126129258, + 126586897, + 126058154, + 128104771, + 126111271, + 127101022, + 126308805, + 126692117, + 125657601, + 130359707, + 133347347, + 130020388, + 127703189 + ], + "absolute_median_shift_ns": 148782, + "relative_median_shift": 0.0011692120170181165, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.69775390625, + 0.25927734375, + 0.09033203125 + ], + "voluntary_ctxt_switches": 3580, + "nonvoluntary_ctxt_switches": 11, + "system_ctxt": 344069 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.72216796875, + 0.27197265625, + 0.095703125 + ], + "voluntary_ctxt_switches": 3648, + "nonvoluntary_ctxt_switches": 13, + "system_ctxt": 368735 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 15, + "session": 2, + "a": { + "median_ns": 125983672, + "mad_ns": 402724, + "iqr_ns": 953551.0, + "min_ns": 125128615, + "max_ns": 130009314, + "n": 15 + }, + "b": { + "median_ns": 126378770, + "mad_ns": 883473, + "iqr_ns": 3053581.0, + "min_ns": 124983187, + "max_ns": 129985271, + "n": 15 + }, + "raw_a_ns": [ + 130009314, + 125656410, + 125580948, + 127089765, + 125697538, + 125682421, + 125983995, + 125972023, + 125983672, + 126174239, + 126708603, + 125203030, + 125128615, + 126609961, + 126424081 + ], + "raw_b_ns": [ + 125480974, + 124983187, + 128868978, + 126603725, + 126094217, + 126378770, + 125700977, + 128754558, + 128982112, + 129985271, + 128379454, + 125495297, + 126142938, + 125834190, + 127159278 + ], + "absolute_median_shift_ns": 395098, + "relative_median_shift": 0.0031361048120585023, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.72216796875, + 0.27197265625, + 0.095703125 + ], + "voluntary_ctxt_switches": 3648, + "nonvoluntary_ctxt_switches": 13, + "system_ctxt": 368736 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.74462890625, + 0.2841796875, + 0.1005859375 + ], + "voluntary_ctxt_switches": 3716, + "nonvoluntary_ctxt_switches": 14, + "system_ctxt": 390412 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 15, + "session": 3, + "a": { + "median_ns": 127740715, + "mad_ns": 1531203, + "iqr_ns": 3061715.0, + "min_ns": 125267404, + "max_ns": 133923263, + "n": 15 + }, + "b": { + "median_ns": 127934620, + "mad_ns": 817704, + "iqr_ns": 1757550.0, + "min_ns": 126819482, + "max_ns": 131996603, + "n": 15 + }, + "raw_a_ns": [ + 125267404, + 126150508, + 126292127, + 126501048, + 127740715, + 128818206, + 126532829, + 127334999, + 125855029, + 130135023, + 128409251, + 129456275, + 129353842, + 129271918, + 133923263 + ], + "raw_b_ns": [ + 129701427, + 128714888, + 127680515, + 128256560, + 127228960, + 127105625, + 127934620, + 127347106, + 126819482, + 129721565, + 128752324, + 126937799, + 131996603, + 128986510, + 127546598 + ], + "absolute_median_shift_ns": 193905, + "relative_median_shift": 0.001517957684830557, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.74462890625, + 0.2841796875, + 0.1005859375 + ], + "voluntary_ctxt_switches": 3716, + "nonvoluntary_ctxt_switches": 14, + "system_ctxt": 390412 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.76513671875, + 0.29638671875, + 0.10546875 + ], + "voluntary_ctxt_switches": 3784, + "nonvoluntary_ctxt_switches": 21, + "system_ctxt": 415060 + } + }, + { + "target_ms": 128, + "iterations": 87280771, + "repetitions": 15, + "session": 4, + "a": { + "median_ns": 126883004, + "mad_ns": 1220032, + "iqr_ns": 2918381.0, + "min_ns": 125313739, + "max_ns": 134833244, + "n": 15 + }, + "b": { + "median_ns": 126530912, + "mad_ns": 944674, + "iqr_ns": 1793291.0, + "min_ns": 125314185, + "max_ns": 129673307, + "n": 15 + }, + "raw_a_ns": [ + 127261894, + 128702179, + 128337235, + 125313739, + 125705793, + 126883004, + 128771574, + 126295477, + 126464791, + 129559567, + 134833244, + 131622969, + 125662972, + 125853193, + 126774502 + ], + "raw_b_ns": [ + 127075243, + 127731048, + 128944179, + 127211313, + 125396538, + 125586238, + 127692872, + 127516210, + 126530912, + 126341705, + 125314185, + 129673307, + 126395347, + 125949384, + 125899581 + ], + "absolute_median_shift_ns": 352092, + "relative_median_shift": 0.0027749343008934436, + "scheduler_before": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.76513671875, + 0.29638671875, + 0.10546875 + ], + "voluntary_ctxt_switches": 3784, + "nonvoluntary_ctxt_switches": 21, + "system_ctxt": 415065 + }, + "scheduler_after": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.8642578125, + 0.32470703125, + 0.11572265625 + ], + "voluntary_ctxt_switches": 3852, + "nonvoluntary_ctxt_switches": 27, + "system_ctxt": 440356 + } + } + ] +} diff --git a/docs/evidence/round6/p022-263a-round6-scales.linux.json b/docs/evidence/round6/p022-263a-round6-scales.linux.json new file mode 100644 index 00000000..e94f0a13 --- /dev/null +++ b/docs/evidence/round6/p022-263a-round6-scales.linux.json @@ -0,0 +1,80 @@ +{ + "schema": 1, + "tag": "CALIBRATION_ONLY", + "kind": "own.net/p022/round6-scales", + "not_decision_evidence": "Setup pass. Fixes the helper's work per rung. No verdict, no tolerance, no threshold.", + "helper_sha256": "f937b36bd4dac422f88942b87ea9794e2c75a198a034917e6c02c0abad1c0cbd", + "helper_source": "scripts/round6/spin.c", + "spawn_floor_ms": 1.332, + "iterations_per_ms": 689051.5, + "warmup_discards": 2, + "rungs": [ + { + "target_ms": 1, + "iterations": 0, + "achieved_median_ms": 1.448, + "at_or_below_spawn_floor": true + }, + { + "target_ms": 2, + "iterations": 460280, + "achieved_median_ms": 2.0128, + "at_or_below_spawn_floor": false + }, + { + "target_ms": 4, + "iterations": 1838383, + "achieved_median_ms": 4.09, + "at_or_below_spawn_floor": false + }, + { + "target_ms": 8, + "iterations": 4594589, + "achieved_median_ms": 8.499, + "at_or_below_spawn_floor": false + }, + { + "target_ms": 16, + "iterations": 10107001, + "achieved_median_ms": 16.4963, + "at_or_below_spawn_floor": false + }, + { + "target_ms": 32, + "iterations": 21131826, + "achieved_median_ms": 31.6907, + "at_or_below_spawn_floor": false + }, + { + "target_ms": 64, + "iterations": 43181474, + "achieved_median_ms": 63.3262, + "at_or_below_spawn_floor": false + }, + { + "target_ms": 128, + "iterations": 87280771, + "achieved_median_ms": 127.3134, + "at_or_below_spawn_floor": false + } + ], + "scheduler": { + "cpu_affinity": [ + 0, + 1, + 2, + 3 + ], + "cpu_count": 4, + "loadavg": [ + 0.18505859375, + 0.09912109375, + 0.02880859375 + ], + "voluntary_ctxt_switches": 224, + "nonvoluntary_ctxt_switches": 1, + "system_ctxt": 289350 + }, + "platform": "Linux-6.18.44-fc-v24-x86_64-with-glibc2.39", + "timestamp_utc": "2026-09-10T16:30:50Z" +} diff --git a/docs/evidence/round7/p022-263a-round7-dataset.linux.json b/docs/evidence/round7/p022-263a-round7-dataset.linux.json new file mode 100644 index 00000000..40f2d5b5 --- /dev/null +++ b/docs/evidence/round7/p022-263a-round7-dataset.linux.json @@ -0,0 +1,33333 @@ +{ + "tag": "CALIBRATION_ONLY", + "mode": "measure", + "timestamp_utc": "2026-09-11T07:03:19Z", + "work_binding": { + "iterations": 460280, + "helper_sha256": "f937b36bd4dac422f88942b87ea9794e2c75a198a034917e6c02c0abad1c0cbd", + "round6_achieved_median_ms": 2.0128, + "source": "docs/evidence/round6/p022-263a-round6-scales.linux.json", + "target_rung_ms": 2 + }, + "preflight": { + "checks": { + "B1": { + "pass": true, + "symbol_size": 1626024, + "section": ".rodata", + "section_size": 1626056, + "why": "own_round7_padding is 1626024 bytes in .rodata (1626056 bytes)" + }, + "B2": { + "pass": true, + "section": ".rodata", + "segment_vaddr": 8192, + "segment_memsz": 1626276, + "segment_flags": 4, + "why": "the padding lies in SHF_ALLOC section .rodata, wholly inside the PT_LOAD at 0x2000 (1626276 bytes mapped)" + }, + "B3": { + "pass": true, + "arm_b_mapped_bytes": 1628917, + "arm_c_mapped_bytes": 1628892, + "delta_bytes": 25, + "page_bytes": 4096, + "arm_b_file_bytes": 1642152, + "arm_c_file_bytes": 1841648, + "why": "arm B maps 1628917 bytes against arm C's 1628892, a difference of +25 bytes" + }, + "B4": { + "pass": true, + "test": "raw-bytes", + "size": 107, + "sha256": "69126786004d1e128458c1054e6a67a2534397146cf8a4f0d5e838b18fc70797", + "why": "main is 107 bytes and byte-identical in both arms; the disassembly fallback was not needed" + } + }, + "failed": [] + }, + "outcome_preflight": { + "ran": true, + "all_passed": true, + "failed": [], + "arms": { + "A": { + "role": "A", + "pass": true, + "expected_rc": 0, + "observed_rc": 0, + "contract": "exit code only; the helper writes nothing by construction", + "why": "ran 460280 iterations and exited 0", + "stdout_bytes": 0, + "stderr_bytes": 0 + }, + "B": { + "role": "B", + "pass": true, + "expected_rc": 0, + "observed_rc": 0, + "contract": "exit code only; the helper writes nothing by construction", + "why": "ran 460280 iterations and exited 0", + "stdout_bytes": 0, + "stderr_bytes": 0 + }, + "C": { + "role": "C", + "pass": true, + "expected_rc": 2, + "observed_rc": 2, + "contract": "perf_baseline rung 'core-usage': expect_rc [2], evidence 'usage-help'", + "why": "satisfied the instrument's own core-usage contract", + "problems": [] + } + }, + "note": "untimed; no clock was started for any of these probes" + }, + "frozen_arms": { + "A": { + "role": "A", + "name": "arm-a", + "sha256": "f937b36bd4dac422f88942b87ea9794e2c75a198a034917e6c02c0abad1c0cbd", + "file_bytes": 15960 + }, + "B": { + "role": "B", + "name": "arm-b", + "sha256": "0bd6ecc40dfc5c51fbda073fe248d90f6378257e701909d274ea294a742d3c5f", + "file_bytes": 1642152 + }, + "C": { + "role": "C", + "name": "rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "file_bytes": 1841648 + } + }, + "schedule": { + "seed": "0xf937b36bd4dac422", + "seed_source": "first 16 hex digits of helper_sha256 in docs/evidence/round6/p022-263a-round6-scales.linux.json", + "design": "blocked randomisation; block = (regime, n, session)", + "blocks": 40, + "halves": 240, + "regimes": [ + "process-cold", + "warm" + ], + "repetition_counts": [ + 5, + 15 + ], + "sessions_per_cell": 10, + "planned_order": [ + { + "block": "process-cold|n5|s9", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "warm|n5|s10", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "warm|n5|s9", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "warm|n5|s4", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n5|s4", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n15|s8", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n15|s2", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n5|s2", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n5|s5", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s10", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s6", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "process-cold|n15|s9", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s7", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n15|s6", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "process-cold|n15|s2", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s7", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s1", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "warm|n5|s7", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n15|s9", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s6", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "process-cold|n5|s10", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n5|s8", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "process-cold|n15|s5", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "warm|n15|s3", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "process-cold|n15|s1", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "process-cold|n5|s2", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s8", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "process-cold|n15|s3", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n15|s7", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n5|s5", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s4", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n5|s3", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n5|s3", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n15|s10", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "warm|n15|s5", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n5|s6", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n15|s4", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n15|s1", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n15|s8", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n5|s1", + "arm_order": [ + "A", + "B", + "C" + ] + } + ], + "tag": "CALIBRATION_ONLY" + }, + "planned_process_spawns": 2640, + "stop_conditions": [], + "measurements": [ + { + "half": "process-cold|n5|s9|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2948601, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1678000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1814052, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1572000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2069696, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1676000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1729653, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1510000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1782474, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1583000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s9|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1746587, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1542000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1808592, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1583000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2000899, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1737000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1832018, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1593000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1824510, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1619000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s9|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2502657, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2261000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534085, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2497707, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2308000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2431518, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564895, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2329000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s9|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2554038, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2367000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2431066, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2235000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2581175, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2361000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2426908, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2475724, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2286000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s9|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2524020, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2566488, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2575776, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2373000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2568806, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2341000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2476895, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s9|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2543720, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2329000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2681788, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2414000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2563316, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2744998, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2499000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518723, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2318000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s10|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1730806, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1513000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2032422, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1767000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2208108, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1908000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2023181, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1771000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1733726, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1502000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s10|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1792833, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1552000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1909238, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1660000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1935128, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1636000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1704275, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1451000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1729508, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1529000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s10|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2541019, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2320000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2419738, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2225000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2522214, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2478778, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2252000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2587026, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2341000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s10|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2480103, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2648193, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2686886, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2653127, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2341000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2672809, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2343000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s10|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2665999, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2340000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2654929, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2669487, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2705309, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2360000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2584545, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s10|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2524095, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2237000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2765821, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2656283, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2324000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2630537, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2654254, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s9|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2479033, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2561159, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2354000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3288507, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 3086000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467629, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2271000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2908383, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2646000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s9|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2452745, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534025, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2340000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3163277, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2968000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2451346, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2480895, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2283000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s9|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2111711, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1844000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1739982, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1550000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2490938, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2237000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1724901, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1439000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1892801, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1639000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s9|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1743104, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1538000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1735440, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1547000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2365855, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2055000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1692707, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1489000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1966757, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1717000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s9|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2487656, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2293000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2573324, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2854064, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2477000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504906, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2276000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2529488, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2268000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s9|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2505451, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2288000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2682183, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2443000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2680230, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2402000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2583083, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2363000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2560837, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2336000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s4|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2544281, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2349000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565540, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2529080, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2333000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2507419, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2272000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2753546, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2547000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s4|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2465779, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2496549, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562717, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2542952, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2345000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474698, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s4|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2542367, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2577970, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2347000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2487364, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2655359, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2310000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2634387, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2316000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s4|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2636079, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2438273, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2251000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2412690, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2224000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2621513, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2280000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2495349, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s4|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1731363, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1497000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1906108, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1695000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1734854, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1560000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1595441, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1413000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1764891, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1575000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s4|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1771963, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1523000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1912785, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1644000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1681459, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1412000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1809100, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1584000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1772404, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1577000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s4|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2659451, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2424000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468105, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2275000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2496012, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2314000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2559405, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2380000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518791, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2287000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s4|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2476563, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2279000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2557583, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2327000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2486085, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2536962, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2309000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2547747, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2256000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s4|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2446941, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2472411, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2302000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2495277, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2295000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2511511, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2491777, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s4|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2587056, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2348000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2561884, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2359000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2591941, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2392000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2424640, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2570171, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2358000, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s4|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1809877, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1612000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1920118, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1675000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1835731, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1566000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1737528, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1551000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1632626, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1450000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s4|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1688882, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1500000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1595668, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1400000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1725786, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1524000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2028207, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1713000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1963044, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1703000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s8|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2521443, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2324000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2479258, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2275000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513524, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2654406, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2396000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2448648, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2561265, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2353000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2450532, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508184, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2239000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2679204, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2400000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2456080, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2252000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2537079, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2286000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2507093, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2484357, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510124, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2309000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2615953, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2394000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s8|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2407246, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2210000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2582328, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2287000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2619003, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2271000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539934, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2576255, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2367000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2463985, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2267000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2516689, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518832, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2624975, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2349000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510279, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2579796, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2610160, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2376000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2670319, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2385000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2608217, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2376000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2480489, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s8|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1844320, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1495000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1727618, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1534000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1838317, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1640000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1700114, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1507000, + "cpu_system_ns": 0, + "minor_faults": 87, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1737258, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1515000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1679708, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1477000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1739083, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1553000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1619733, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1432000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1794625, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1589000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1815227, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1573000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1709497, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1510000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1714902, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1509000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2061086, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1772000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2590077, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2121000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1948245, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1532000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s8|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2510084, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1829000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2625284, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1897000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2697024, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2235000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2080535, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1516000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1851162, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1622000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2234414, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1600000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2352909, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1837000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2080413, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1777000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2024175, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1621000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2259526, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1865000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1935361, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1627000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2175068, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1812000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2271853, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1932000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1792152, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1521000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1990691, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1738000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s8|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2561678, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2446382, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2515530, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2325000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2622532, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2442000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508138, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2301000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3103525, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2889000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2604443, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2387000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2550083, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2340000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2535814, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2611518, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2382000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2635270, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2397000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2536220, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2332000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3179784, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2976000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2485581, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2267000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526255, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s8|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2483942, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605355, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2396000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2545855, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2267000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2896938, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2698000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2608164, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2387000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2520542, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2318000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2543592, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2434229, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2248000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2481018, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2203000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2561050, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2364000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2458237, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2509547, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2589926, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2379000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558737, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2358000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565399, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s2|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2597894, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2367000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2589359, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2612604, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2390000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2476363, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2252000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3838236, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 3639000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3009923, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2664626, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2443000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2611056, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2274000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2572866, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2676549, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2464000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558550, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2366000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2718502, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2431000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2699660, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2450000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544044, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2538186, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2259000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s2|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2587466, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2380000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2717749, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2493000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3955520, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2824000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2650536, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2407000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3051176, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2815000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2667642, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2410000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3083191, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2867000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2514524, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2703432, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2448000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2618387, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2387000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2611023, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2368000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2831338, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2451000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2611603, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2393000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2654147, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2404000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2843634, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2502000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s2|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2622972, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2380000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2780263, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2551000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2840258, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2651000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2606564, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2398000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2658998, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2449000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2529321, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2283000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2552947, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2351000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564679, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2339000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3087639, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2341000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2571851, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2379000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2667408, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2473000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2472338, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2250000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2489186, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534921, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2314000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2456577, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s2|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2421839, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510484, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2877677, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2630000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2499133, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2231000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2505279, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2555245, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2530254, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2308000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2734610, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2493000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2610277, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2632554, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2401000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2619853, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2402000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2543610, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605840, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2356000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2610329, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2357000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2590356, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2381000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s2|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1832850, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1514000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1815781, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1532000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1856075, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1564000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1774324, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1439000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1818048, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1477000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2057900, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1689000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2143359, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1784000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1761104, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1446000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1781377, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1493000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1788395, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1510000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1800994, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1519000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1831098, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1455000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2087078, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1674000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1872359, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1438000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2248572, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1554000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s2|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1888978, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1441000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1802731, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1509000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1928890, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1617000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1773560, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1479000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2111964, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1733000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1855985, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1524000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1871013, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1544000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1790012, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1472000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1850059, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1527000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2075652, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1643000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1857721, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1537000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1729207, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1431000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1819792, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1532000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1833540, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1500000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1841291, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1511000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s2|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2750219, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2356000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2924040, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2339000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2735507, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2636952, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2693162, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2318000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s2|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2616279, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2681353, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2702935, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2380000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3197307, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2965000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2576444, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2382000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s2|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2625707, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2421000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2959306, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2741000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2767023, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2548000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2561962, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2357000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539661, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2333000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s2|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2671547, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2440000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2971879, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2521000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2953959, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2563000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3057498, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2695000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2579486, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s2|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2211488, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1980000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1792313, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1572000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1865760, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1626000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1761429, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1538000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1770830, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1552000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s2|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1734375, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1510000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2178898, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1916000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1699099, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1478000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1842949, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1611000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1765048, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1531000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s5|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2638804, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2166000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1885891, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1614000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2142374, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1884000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1991151, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1657000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1806334, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1521000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s5|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1810558, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1573000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1927804, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1677000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1677839, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1462000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1849124, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1650000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2017152, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1752000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s5|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2764596, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2338000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2571102, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2363000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2521617, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2955864, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2619000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2838115, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2455000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s5|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 3016080, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2622000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2726636, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2379000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2854309, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2500000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2663723, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2345000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2607979, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s5|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2729603, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2400000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2733163, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2752901, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2377000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2716052, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2583582, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s5|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2400335, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2204000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513913, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2274000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2469246, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2282000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2425319, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2215000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2781571, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2530000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s10|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2214249, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1783000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2246098, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2002000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1847081, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1608000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1874625, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1601000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2939859, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2492000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2215908, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1894000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1806956, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1590000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1746338, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1545000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2163158, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1908000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2127562, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1944000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1717081, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1516000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2178784, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1970000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1634744, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1455000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2334970, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2149000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1677506, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1479000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s10|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1967823, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1750000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1783963, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1556000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1977173, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1743000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2001620, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1702000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2118509, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1864000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1713820, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1531000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1775890, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1528000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1840804, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1526000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1880454, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1535000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2096916, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1637000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2142249, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1821000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2069265, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1733000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2099282, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1772000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2024285, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1649000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2386350, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1961000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s10|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2665981, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3164840, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2931000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2888502, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2615000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2868706, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2672000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2478729, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2284000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2549605, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2351000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2466225, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2287000, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2878941, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2640000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544871, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2326000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2520022, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2295000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2861719, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2619000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2607766, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2381000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2620099, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2399000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2867939, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2663000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467661, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s10|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2677336, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2463000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2502543, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2301000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2546124, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2289000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467579, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2512009, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2211000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2463706, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2525670, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2275000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2714996, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2451000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2594481, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2373000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2567482, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2291000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2584202, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2357000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2692268, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2346000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2691674, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2338000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2695380, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2374000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2833282, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2495000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s10|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2633399, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2750279, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2390000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2666593, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2588238, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2262000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2630070, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2248000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2608988, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2657677, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2335000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2603508, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2367000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3071176, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2847000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2546874, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2326000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2903444, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2590000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2782718, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2500000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2531864, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3030657, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2730000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544085, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2316000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s10|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2566670, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602141, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2371000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2546559, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2328000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2479502, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2290000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2625177, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2412000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2828127, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2584000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2591246, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2383000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2771827, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2484000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2745585, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2518000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558444, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2321000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2517568, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2308000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2559462, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2495498, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467295, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2241000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2506002, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2275000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s6|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2771056, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2473000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2722906, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2334000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2572741, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2241000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2661986, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2323000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2705502, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2370000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s6|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2582953, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2237000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2815184, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2444000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2763823, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2389000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2727098, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2337000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2730676, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2385000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s6|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2623107, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2719018, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2324000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2664203, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2704849, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2351000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2580568, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2225000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s6|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2621110, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2306000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2739406, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2357000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3024052, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2703000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2614555, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3128208, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2796000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s6|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1928263, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1543000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2311868, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1912000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2569949, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2033000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2041716, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1561000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2057863, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1587000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s6|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2139416, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1636000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2321741, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1735000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2062517, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1610000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2290025, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1634000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2010268, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1538000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s9|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2373239, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1757000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2208969, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1809000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1895226, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1529000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 4913900, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1492000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1914006, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1579000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1906029, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1597000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2221392, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1850000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1979467, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1585000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1951648, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1560000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1922387, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1542000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2009731, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1693000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2053140, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1645000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1918248, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1604000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2044617, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1560000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2056106, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1579000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s9|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2106789, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1751000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2135494, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1516000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1863781, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1516000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2064412, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1737000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2263969, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2040000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1787024, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1505000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1777867, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1536000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2540542, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2270000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1748484, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1545000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1782587, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1486000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2517238, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2295000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1742356, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1529000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1753207, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1549000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1822971, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1472000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2316797, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2051000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s9|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2769695, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2595704, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2359000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2507591, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2507248, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2581499, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2390000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2436065, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2247000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564674, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2368000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2494540, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2290000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2420685, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2220000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2482849, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2291000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2555667, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2404840, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2210000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562223, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2355000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2522144, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2633339, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2413000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s9|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2488669, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2559407, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2280000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2614873, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2577248, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2702992, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2399000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2640755, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2354000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2660801, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2343000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602288, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2228000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2807118, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2497000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2657240, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2355000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2631425, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2274000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3037690, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2658000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2867103, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2494000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2681416, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2326000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2573233, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s9|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2705402, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2355000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2596124, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2268000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2604057, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2193000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2877720, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2407000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2807038, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2480000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2588520, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2711701, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2403000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2674967, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2346000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2724177, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2404000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2659201, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2364000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2679132, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2306000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2616702, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2275000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2671893, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2889403, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2427000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2601066, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2256000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s9|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2651708, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2350000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2703214, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602074, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2249000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2653260, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2341000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2609688, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2713186, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2293000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2713035, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2384000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2674560, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3083283, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2730000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2682214, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2274000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2956216, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2651000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2619206, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2880473, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2574000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2743708, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2438000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2658000, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2311000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s7|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2214620, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1684000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2737394, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2293000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1976406, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1541000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1872038, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1470000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2600853, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2189000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1875831, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1456000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2342408, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1908000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2153239, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1690000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1932590, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1528000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3013476, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2198410, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1750000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2108016, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1723000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2989486, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2613000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2009287, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1547000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2674250, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1686000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s7|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2350604, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1909000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1956974, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1431000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2677967, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2296000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2695037, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2669920, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2399375, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1951000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2005486, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1682000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2391442, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2034000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1829896, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1524000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1928983, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1638000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1977618, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1616000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2299056, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1988000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1729699, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1409000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2094721, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1674000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2034322, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1519000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s7|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 3180863, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2674000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2867510, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2832798, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2283000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2906105, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2578000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2741643, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2457000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2629742, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2231000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2723941, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2326000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2704668, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2388000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2540389, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2247000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2569430, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2205000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2779941, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2800630, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2267000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2736722, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2856280, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2412000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2652485, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s7|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2762903, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2881159, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2346000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2849060, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3169318, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2583000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2771572, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2770388, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2343000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2895319, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2535000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2600441, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2242000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2653242, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2675370, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2367000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2986919, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2637000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2789557, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3146406, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2601000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2799527, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2268000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3088242, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2613000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s7|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2858504, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2271000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3059290, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2591000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2796041, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2314000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3048715, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2590000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2954937, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2476000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2907331, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2429000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2916881, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2441000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 4989805, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2778000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2994023, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2450000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3078146, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2546000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2841625, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2349000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2766715, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2321000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3099079, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2530000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2749060, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2871035, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2366000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s7|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2771171, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2284000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2880898, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3048574, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2437000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2857455, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2348000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2805745, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2283000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2849024, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2349000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2920957, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2396000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2803286, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2699975, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2234000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2789874, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2816415, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2361000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2811985, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2237000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2703034, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2771601, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2304000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2714759, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s6|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2701414, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2252000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2658193, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2358000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2578798, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2270000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2567522, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2270000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2647188, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2352000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605902, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2556518, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2571886, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2291000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2617391, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2270000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558814, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2700576, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2364000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2593133, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2293000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2498311, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2206000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2677913, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2503261, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2222000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s6|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2547597, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2251000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2670310, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2360000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2913580, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2710000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2454044, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2254000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2546744, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2332000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468982, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2527385, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2570909, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2259000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2554590, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2270000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2497410, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2612857, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2301000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2655421, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2409135, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2206000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2662287, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2430000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2456280, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2250000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s6|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1763332, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1571000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2155873, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1940000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1626523, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1428000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1659843, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1437000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2124690, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1932000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1595858, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1419000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1644474, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1470000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2110375, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1931000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1710904, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1520000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1668495, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1453000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1696980, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1499000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1615504, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1438000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1653307, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1436000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1841503, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1641000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1630247, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1445000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s6|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1965772, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1735000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1842177, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1609000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1852487, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1678000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1930394, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1728000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2400614, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2163000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1650042, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1469000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2243602, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2071000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1917596, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1683000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1846795, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1530000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1715600, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1455000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2362815, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2122000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1635737, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1436000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1818130, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1572000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1640527, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1461000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1972346, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1712000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s6|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2428458, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2571834, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2230000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2481800, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2402226, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2442988, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2449568, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2367894, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2191000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2543697, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2369000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2443516, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2263000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2724217, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2497874, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2425594, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2215000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2485577, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2481367, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2436272, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2219000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s6|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2566005, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2495687, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2272000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2434775, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2593354, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2484092, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2288000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2444614, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2250000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2458486, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2264000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2493293, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2452170, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2210000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2445809, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2261000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2477795, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2259000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2453470, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2253000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2487647, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2409861, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2210000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2459092, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2239000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s2|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2202379, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1855000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1697376, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1485000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1989214, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1717000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1750926, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1456000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1776556, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1500000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2164138, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1869000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1747753, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1536000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1623165, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1414000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1640833, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1429000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1686478, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1489000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1705433, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1478000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1671908, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1474000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1661143, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1468000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1666950, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1456000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1709642, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1427000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s2|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1919380, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1635000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1950149, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1698000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1890489, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1644000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1737287, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1534000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1691473, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1484000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1707788, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1492000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1663181, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1443000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1754313, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1567000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1635909, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1453000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1644006, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1434000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1680217, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1502000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1625683, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1422000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1728630, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1501000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1840906, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1584000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1787977, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1579000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s2|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2913401, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2698000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2484606, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2446370, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2249000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2520717, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544166, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2341000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467969, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2282000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2491194, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2278000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2519650, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 2, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2471743, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2529263, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2538264, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2464051, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2524131, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2547499, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2543053, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2250000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s2|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2516179, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2535706, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2685985, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2347000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2483211, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2583693, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2228000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2644962, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2346000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2486603, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2284000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2637949, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2335000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2653577, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2626093, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2661581, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2309000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2693312, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2442000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2567433, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2311000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2475949, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2618350, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2346000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s2|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2515356, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2428778, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565789, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2487373, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2249000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2553253, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2300000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562473, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2291000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544630, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2597040, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2371000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2488318, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2490790, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2288000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544476, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2337000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2514183, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2318000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2570261, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2353000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2731559, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2486000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558745, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2308000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s2|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2486872, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2225000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2955035, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2732000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2494641, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2300000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474463, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2574429, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2363000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467861, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2498438, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2269000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565264, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2355000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2482333, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526505, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2501837, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2478037, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2251000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2523218, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2323000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2505358, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2311000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2499113, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s7|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1822985, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1584000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1940389, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1739000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1710008, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1457000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1717519, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1514000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1958991, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1658000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s7|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1699076, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1511000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1895283, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1663000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1714216, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1529000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1926092, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1656000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1625391, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1434000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s7|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2461959, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2271000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2447147, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2444422, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2263000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467552, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2501221, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2311000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s7|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2495121, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2434492, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2224000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2494694, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2247000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504609, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2302000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2383397, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2195000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s7|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2538533, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2355000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2438333, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2253000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467610, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2239000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2541969, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2340000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2436161, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2221000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s7|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2497110, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2226000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2495471, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2420990, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2230000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2501299, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2555754, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s1|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2556692, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2316000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2519533, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2222000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2554124, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2346000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2466235, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2496042, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2225000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s1|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2636395, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2427000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2523955, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2706118, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2413000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2632322, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2364000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3160176, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2849000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s1|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1985797, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1723000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1884981, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1606000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1829666, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1604000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1743941, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1530000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1697796, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1398000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s1|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1662228, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1466000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2208745, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1974000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1708436, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1522000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1619172, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1443000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1616575, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1411000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s1|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2502452, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2252000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2412801, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513225, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2304000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2454576, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2270000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508688, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2219000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s1|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2590423, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2373000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2540316, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2313000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518437, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2295000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2647343, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2435000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2551724, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2328000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s7|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1642815, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1448000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1787669, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1567000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1898452, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1651000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1729779, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1525000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1676813, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1488000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s7|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1896480, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1650000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1721425, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1515000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1864740, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1607000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1742636, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1525000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1719864, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1537000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s7|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2441314, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2238000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508106, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2318000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3137614, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2957000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2433178, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2238000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2531735, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2308000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s7|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2451539, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2272000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3136326, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2948000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2497659, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2512225, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3132678, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2936000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s7|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2491934, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2308000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2423220, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2472198, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2282000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2499480, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2252000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3396716, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 3034000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s7|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2967468, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2771000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2866420, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2662000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2516208, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2315000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3002848, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2770000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3318493, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 3071000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s9|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1784090, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1576000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1757737, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1536000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2685632, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2032000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1735098, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1532000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2019672, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1823000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1689441, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1476000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1799001, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1508000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1719033, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1508000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1819581, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1569000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1864877, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1614000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1712023, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1492000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1734726, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1396000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1658871, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1468000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1919806, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1684000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1615290, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1429000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s9|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1725254, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1521000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1617820, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1393000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1633271, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1449000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1687710, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1466000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1745612, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1561000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1688169, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1509000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1881162, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1626000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1655440, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1413000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1637799, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1388000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1780560, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1577000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1844070, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1543000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1744233, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1487000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1715678, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1521000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1851903, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1591000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1948087, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1707000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s9|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2635870, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2434000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2432485, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2241000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 18005232, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2517000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2598609, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2332000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2618206, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2395000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2657488, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2442000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2486352, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2647450, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2450000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539851, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2822203, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2621000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2473182, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2276000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2567785, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2442341, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2887706, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2662000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2516657, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2314000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s9|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2598477, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2359000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2465615, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2256000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2896243, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2689000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510106, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2262000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2424930, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2223000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2535626, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2302000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2417720, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2225000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2656482, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2408000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 2, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513973, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2439270, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2247000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2537933, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2349000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2437092, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2251000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2499058, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2248000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2525147, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504198, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2283000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s9|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2577471, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2259000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2652253, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2848860, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2513000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2594669, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2580956, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2206000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2766395, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2449000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2603593, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2673981, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2226000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2719524, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2302000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2548772, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2251000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2547477, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2706796, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2392000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2551992, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2220000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605748, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2226000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2649593, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2325000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s9|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2624333, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534742, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2682838, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2390000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2575543, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2556683, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2198000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2623754, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2560555, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2239000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2733278, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2651956, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2358000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2611593, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2302000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2587416, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2254000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2671488, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2384000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562980, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2525100, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2235000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2633897, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2339000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s6|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2735188, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2376000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2582580, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2685485, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2390000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2652895, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2332000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539282, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2598136, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2665506, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2556663, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2249000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2557430, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2658387, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2551528, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2239000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2530171, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2233000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2603699, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2279000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2536302, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2727212, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2208000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s6|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2623637, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2528261, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2230000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2637292, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2283000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2615749, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2535027, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2230000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2769022, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2183000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3314476, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2925000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2492409, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2887709, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2672000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2553265, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526476, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2318000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2808787, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2618000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2621141, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2384000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2630314, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2321000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2849151, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2626000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s6|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2526852, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2511925, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2292000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2486771, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2755498, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2328000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2482932, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2289000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2438209, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2248000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539568, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2344000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2448645, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2261000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2614047, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2406000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2410710, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2233000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2453765, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2237000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2662932, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2468000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508856, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534459, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 27658047, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s6|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2992068, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2535000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2827062, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2429000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2619019, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2295000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2696627, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2360000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602161, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2316000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2611250, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602327, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2595467, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2684470, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2385000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2790055, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2477000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2720709, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2498000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2434351, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2233000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2525257, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2343000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2710339, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2529000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2420004, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2237000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s6|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2361823, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2091000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1884168, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1655000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1710382, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1525000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1647440, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1441000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2096283, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1911000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1634737, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1452000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1633721, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1433000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2030427, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1755000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1602403, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1425000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1727917, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1533000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1631790, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1453000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2037249, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1852000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1688938, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1505000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1688817, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1491000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1630042, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1446000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s6|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2050823, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1818000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1615071, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1430000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1970913, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1772000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1715454, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1503000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1653034, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1465000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2056382, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1880000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1626379, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1417000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2291929, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2068000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1674197, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1477000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1663304, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1490000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1647768, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1458000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2245464, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2069000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1623832, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1433000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1700413, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1468000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1777521, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1405000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s10|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2851238, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2463000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2571066, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2656453, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2352000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2781210, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2472000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2603948, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2337000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s10|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2588900, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2495159, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2288000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2496602, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565418, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2368000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2458980, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s10|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1778493, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1592000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1954141, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1753000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1755486, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1562000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1700900, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1516000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1799041, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1579000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s10|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1756557, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1469000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2010143, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1767000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1700394, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1497000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2226800, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2035000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1676062, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1476000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s10|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2502931, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2311000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544564, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2587166, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2354000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2631382, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2400000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2591733, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2393000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s10|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2585921, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2356000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2537790, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2314000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2555744, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2304000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2524702, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2321000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2441087, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2233000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s8|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2590212, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2350000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518153, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2271000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2382802, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2186000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2561474, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2487139, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s8|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2483681, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2515738, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2776869, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2429000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562100, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2658693, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2371000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s8|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1983417, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1510000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1859694, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1488000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2240877, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2015000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1785960, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1581000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1963748, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1668000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s8|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2071845, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1879000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1749468, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1568000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2159115, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1945000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1939458, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1743000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1663576, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1479000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s8|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2618978, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2382000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467665, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2291000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2483023, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2774865, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2596000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2628328, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2415000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s8|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2474155, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2823037, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2644000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2485315, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2460721, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2506961, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s5|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2457901, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2492403, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468184, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2522958, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2246000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2593336, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2404000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2506809, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2498975, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468995, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2270000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2621542, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2381000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508303, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2327000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2431880, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2252000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468350, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2208000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2476399, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2292000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2416919, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2224000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2506124, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s5|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2432441, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2242000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2454145, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2529919, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2318000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2451700, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2521697, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2297000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2463347, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2262000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2503612, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2239000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3284178, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2999000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2580996, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2333000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2646823, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2455353, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2213000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508535, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2306000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2789392, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2558000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2719107, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2233000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2654611, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s5|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2620476, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2647000, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2398000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2584399, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2584895, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2691584, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2309000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3002288, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2676000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2745247, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2596503, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2573203, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2345000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2598650, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2388000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2484973, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2560289, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2367000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2511489, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2306000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2725876, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2469000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2889532, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2582000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s5|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2473667, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2601652, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2349000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2699640, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2367000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2586820, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2559798, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2282000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2577135, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2353000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2466340, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2256000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2599276, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2382000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2475587, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2281000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2647500, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2456000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3127270, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2938000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2550469, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2343000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3007271, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2721000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526655, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2247000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2598560, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s5|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1765594, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1566000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1799724, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1616000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2021809, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1751000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1771528, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1529000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1761210, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1566000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1690526, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1503000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1981205, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1703000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1809257, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1506000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1818054, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1435000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1834302, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1461000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1873165, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1506000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1795341, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1541000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1960280, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1753000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1697492, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1491000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1716958, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1513000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s5|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1684772, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1406000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1782469, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1586000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1606177, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1432000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1691229, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1508000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1724576, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1531000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1871324, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1604000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1816849, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1614000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2348416, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2098000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1717755, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1505000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1604699, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1420000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1863529, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1609000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1650238, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1440000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1743116, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1491000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2038826, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1809000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1679433, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1485000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s3|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2655531, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2396000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3010375, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2813000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526331, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565175, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2353000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2642193, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2421000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2622550, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2428000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2579582, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2500783, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508243, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2576157, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2390000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2451417, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2721885, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2407000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2593844, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2324000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2541294, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2311000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2535745, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s3|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2499312, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2585173, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526005, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2216000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2724550, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2362000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2694219, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468692, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2675187, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2371000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2487777, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2523069, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2188000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2690615, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2452387, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2645384, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2319000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2606003, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2594946, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2284000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2685525, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2339000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s3|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1680473, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1494000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1786712, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1535000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1644452, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1459000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1789568, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1597000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1950083, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1773000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1774044, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1581000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1767717, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1504000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1707725, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1522000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1685078, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1485000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2059945, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1873000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1787002, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1559000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1940513, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1710000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1863152, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1600000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1689420, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1492000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1979326, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1696000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s3|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1837778, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1652000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1980537, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1741000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1662469, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1462000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1781836, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1583000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1621593, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1446000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1655905, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1477000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1656643, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1427000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1881502, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1638000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1760786, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1546000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1743065, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1542000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1670836, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1477000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1676223, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1455000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1735877, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1559000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1682174, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1502000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1592256, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1414000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s3|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2491705, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2588833, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2367000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2622528, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2758024, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2525000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2649842, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2404000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2627129, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2413000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2557382, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3251256, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2902000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3055764, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2677000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2850685, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2443000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2629512, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2733031, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2439000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3119974, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2743000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2780609, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2523000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2644207, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2373000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s3|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2698746, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2301000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2786750, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2472000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2803996, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2543000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2581337, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2614907, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2355000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2677051, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2376000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2743997, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2463000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2622291, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2325000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2604394, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2332000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2635541, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2329000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2834598, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2619000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2610440, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2404000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2876102, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2624000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2780413, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2538000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2546493, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s1|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2736488, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2405000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2855628, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2615000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2630744, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2403000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2557361, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2335000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2673070, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2419000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564672, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2316000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2610469, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2397000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2560683, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2646569, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2369000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605724, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2653863, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2438000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564795, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2322000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2787921, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2565000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2649070, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2381000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2551827, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2314000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s1|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2660485, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2412000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3132774, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2911000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2595739, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2401000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2916424, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2698000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2507743, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2279000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2640886, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2460000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504536, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3186200, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2991000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2715562, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2506000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2506397, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3014270, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2764000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2689568, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2474000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2500350, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2819390, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2598000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2582903, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2379000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s1|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2006733, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1798000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2050482, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1837000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1832843, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1595000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1851131, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1642000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1927323, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1714000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1799707, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1589000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1927757, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1687000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1990001, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1721000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1736077, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1494000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1740806, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1530000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1853423, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1638000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1976385, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1755000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1797890, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1591000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1819942, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1596000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1647211, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1455000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s1|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1732023, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1534000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1885366, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1650000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1728190, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1531000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2037498, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1761000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2106845, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1777000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1796304, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1594000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1731625, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1534000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1730630, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1543000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1862283, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1598000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1826200, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1605000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1850540, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1575000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1952643, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1748000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2153120, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1944000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1792325, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1581000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1804455, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1554000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s1|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2641103, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2433000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2578839, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2321000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2726096, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2499000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2572408, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2363000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2580364, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2348000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2550951, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2357000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2575424, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2384000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2631757, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2407000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2596598, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2340000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2973258, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2547000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2655339, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2386000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2993610, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2753000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2775444, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2549000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2752746, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2520000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2579457, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2318000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s1|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2607138, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2405000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2533248, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2326000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2631565, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2377000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2717488, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2508000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513682, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2302000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2596552, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2366000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2929259, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2700000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2596854, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2356000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2577805, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2819064, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2594000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602327, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2338000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2535114, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2209000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2747540, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2541000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2498518, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2548479, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2317000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s2|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2211006, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1805000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1991845, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1764000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1909815, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1648000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2049264, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1851000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1772364, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1579000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s2|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2007973, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1723000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2145833, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1886000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1976934, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1767000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1803003, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1602000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1796272, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1545000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s2|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2543760, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2695818, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2482000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2488173, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2543090, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2304000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2645050, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2457000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s2|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2511692, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2620730, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2387000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504781, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2302000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2532995, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2690907, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2458000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s2|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2574761, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2306000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2626864, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2414000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2670384, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2444000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2496162, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513082, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2288000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s2|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2649365, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2421000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2485188, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2272000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2406809, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2205000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2517936, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2327000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2498492, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2239000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s8|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2586312, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2272000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2617368, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2397000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2541968, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2327000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2469027, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2803782, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2595000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s8|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2930339, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2726000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2578511, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2358000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2593539, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534040, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2327000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602757, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2388000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s8|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1808405, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1555000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1691824, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1480000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1796098, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1600000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1626940, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1414000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1950945, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1730000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s8|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1923097, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1636000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2261436, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1941000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1702553, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1491000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1781218, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1586000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1790408, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1586000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s8|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2987118, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2790000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2498002, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534691, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2294000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2475635, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2271000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2537836, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s8|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2901019, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2504000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2604899, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2625984, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2247000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2674455, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2460000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2837807, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2615000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s3|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2157282, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1774000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2115843, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1709000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2237818, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1826000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1818413, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1603000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1691178, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1452000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2022689, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1816000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1826008, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1622000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1679344, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1496000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1673265, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1437000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2008091, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1662000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1779746, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1546000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1946614, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1750000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1801418, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1610000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1703171, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1514000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1864356, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1673000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s3|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1664642, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1477000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1692036, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1509000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1834943, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1633000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1720261, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1527000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1825789, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1523000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1630691, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1425000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1800519, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1596000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1921776, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1672000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2018973, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1773000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2006437, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1738000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1831093, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1634000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1680923, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1485000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1739508, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1495000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1769288, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1562000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2189887, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1980000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s3|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2596791, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2375000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2771544, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2557000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2672349, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2462000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2531394, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2532272, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2600266, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2365000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564981, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2356000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565254, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2327000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2864222, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2666000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605942, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2374000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2676208, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2462000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2735339, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2488000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2532184, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2547119, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2363000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2723058, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2504000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s3|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2499255, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2275000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2622178, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2414000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2536217, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2523022, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2253000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2668571, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2433000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2506981, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2697262, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2431000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2545557, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2334000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2523108, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2327000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558351, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2606970, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2399000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2807367, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2597000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2570409, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2689955, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2506000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2415560, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s3|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2727655, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2539000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2484303, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2452490, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2703143, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2476000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2443733, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2428752, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2767036, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2549000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474632, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2287000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2454273, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2217000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2748539, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2547000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2392093, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2200000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504796, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2424675, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2396259, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2202000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2645061, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2461000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s3|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2493394, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2213000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2402937, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2213000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2589964, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2405000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2412621, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2217000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2483312, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2281000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2467934, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468506, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2250000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2924872, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2727000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2445284, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2439147, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2886212, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2695000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2453918, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2478358, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2293000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2873152, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2678000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474332, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2263000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s7|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2026437, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1786000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2186614, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1888000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508176, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2260000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2270548, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1810000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1927763, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1592000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2106927, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1706000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2108116, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1696000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1891252, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1552000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1853906, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1587000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1967271, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1648000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2030367, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1697000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1827614, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1488000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1813798, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1480000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2154278, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1658000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1893643, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1533000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s7|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1851091, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1506000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2277010, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1861000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1816960, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1480000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1847563, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1512000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1791835, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1445000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1821520, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1496000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1792387, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1420000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1873021, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1512000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1819671, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1487000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1814857, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1485000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1900689, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1455000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1841150, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1506000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1947240, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1429000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1980168, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1613000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1759780, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1401000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s7|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2644920, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2404000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474486, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2251000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605919, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2331000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2735632, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2382000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2623541, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2373000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2788276, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2340000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3284470, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2859000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2890602, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2407000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2864986, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2534000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2604757, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2652612, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2378000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2725352, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2497000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2553886, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2651711, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2365000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2652167, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2261000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s7|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2475658, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2274000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2838613, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2609000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2545611, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2463024, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2281000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2568280, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2314000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510205, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2304000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2663564, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2438000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2559184, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2341000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2475406, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2287000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2434901, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2494513, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2293000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2445144, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474260, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2215000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2937066, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2708000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2536764, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s7|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2444733, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2482582, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3357651, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2968000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3000226, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2608000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2709904, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2365000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2755189, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2474000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2653619, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2416000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2668925, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2404000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2702839, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2473000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2600277, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2372000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2710335, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2427000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2710125, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2483000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2679084, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2420000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2582699, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2292000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2996613, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2612000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s7|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2557051, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2654002, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2451000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2717528, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2389000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2696113, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2340000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3120390, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2810000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2959679, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2703000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3158630, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2884000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2629789, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2337000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2788805, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2468000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2780571, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2481000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2611747, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2352000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2616694, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2329000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2628092, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2591808, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2347000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2855779, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2632000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s5|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1842553, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1535000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1805490, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1594000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1868895, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1629000, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1757553, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1545000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2296863, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2098000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s5|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1747008, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1527000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1994818, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1779000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1941216, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1678000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1781331, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1570000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1690990, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1468000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s5|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2517836, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2727947, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2512000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2541842, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2305000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2615532, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2396000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504610, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2304000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s5|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2639413, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2403000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539260, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3152437, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2947000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2671817, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2427000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2665925, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2309000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s5|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2637941, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2731549, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2376000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2733341, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2395000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2667779, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2324000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2642375, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2324000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s5|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2608428, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2238000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2757073, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2417000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2705426, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2403000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2630839, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2267000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2781671, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2473000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s4|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2860663, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2456000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2834221, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2424000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2725304, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2366000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2891422, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2513000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2858701, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2497000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2741024, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2625832, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2300000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2647640, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2290000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2707016, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2940690, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2540000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2761149, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2352000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2690415, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2734655, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2858661, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2493000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2758639, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2429000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s4|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2751098, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2389000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2872922, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2413000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2674774, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2764106, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2351000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3100307, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2757000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2717384, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2763291, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2402000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2974311, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2649000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2669805, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2328000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2815317, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2383000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3146964, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2808000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2662109, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2402000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2944172, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2692000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2599641, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2355000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2676287, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2462000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s4|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 3166964, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2802000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2628843, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2331000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2789364, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2492000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2875083, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2527000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2705797, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2399000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2726609, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2430000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3035542, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2690000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2681756, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2422000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2592151, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2380000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2636143, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2397000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2523367, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2665000, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2434000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2547605, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2626593, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2409000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558382, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s4|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2652535, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2348000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2542096, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2498888, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2290000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2543292, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2348000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510232, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2599006, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2374000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2456949, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2242000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2538676, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2286000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2656712, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2424000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2496630, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2281000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2643515, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2660640, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2423000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2534786, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2823484, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2418000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2689187, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2337000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s4|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1972019, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1629000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2166297, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1811000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1875167, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1564000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1996568, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1675000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1790769, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1521000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2104121, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1819000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1773234, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1451000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1998767, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1668000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1840816, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1564000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1805981, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1520000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1900428, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1624000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1835881, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1553000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1748539, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1474000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1834168, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1547000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1819680, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1399000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s4|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1747621, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1485000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1847152, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1532000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1739950, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1483000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1877585, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1598000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1754532, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1464000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1928912, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1599000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2181865, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1881000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1821598, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1538000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2166083, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1856000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1916149, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1588000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1901849, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1565000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1884020, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1528000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1986368, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1585000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2018216, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1743000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1810459, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1552000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s3|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2647217, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2398000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2732347, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2469000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2549916, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2344000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2594340, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2655242, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2436000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s3|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2557927, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2321000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2466328, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2250000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2629944, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2376000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2688448, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2450000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544369, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s3|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1913005, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1648000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1732753, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1494000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2051138, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1842000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1698007, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1488000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1774573, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1568000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s3|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1766728, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1464000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1649995, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1430000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1776379, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1573000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1657757, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1464000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2155368, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1892000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s3|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2455210, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2254000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564843, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2376000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526084, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2325000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2475540, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2599859, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2358000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n5|s3|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2651210, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2289000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2681850, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2468000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558567, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2339000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562608, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2304000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2450561, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2224000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s3|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2568786, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2380000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562672, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2350000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2599569, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2398000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2436910, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2576469, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2385000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s3|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2569352, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2377000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2536549, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2262000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2446875, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2242000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2533825, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2485504, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2283000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s3|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2019443, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1737000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1675048, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1464000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1944815, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1701000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1775094, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1573000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2189314, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1946000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s3|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1692569, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1474000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1720929, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1519000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1646955, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1465000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1704737, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1519000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1762316, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1577000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s3|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2523418, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2335000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526140, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2328000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2600239, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2400000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2603744, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2291000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2517435, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s3|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2479925, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2267000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2650282, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2452000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2552704, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2351000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2511148, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2260000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2609290, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2401000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s10|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2011415, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1812000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1951632, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1656000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1779299, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1571000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1689979, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1441000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1936435, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1750000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1732736, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1543000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1824122, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1576000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1654352, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1462000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1832861, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1644000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1740468, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1544000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1795766, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1605000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1825245, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1474000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1716718, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1497000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1690016, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1472000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1680690, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1459000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s10|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1791753, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1567000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1744638, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1543000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1680826, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1469000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1789436, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1587000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1849230, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1608000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1771599, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1552000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1802302, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1606000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1782662, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1589000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1681281, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1486000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1782387, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1594000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1720528, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1524000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1641064, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1448000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1727103, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1511000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1927054, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1661000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1766291, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1528000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s10|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2569425, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2359000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2436076, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2225000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2631859, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2415000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2602223, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2412000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2440403, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2215000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2650873, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2461000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2553412, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2320000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2556427, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2360000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2549230, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2367000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2502353, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2687067, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2408000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2584587, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2323000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2466314, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2685086, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2498000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2578847, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2379000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s10|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2589391, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2384000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2478605, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2242000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2530219, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539055, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2517925, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2541673, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2324000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2647867, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2601639, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2780425, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2456000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2621900, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2287000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2626038, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2254000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2690611, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2398000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2590830, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2663774, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2293000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2504965, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2294000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s10|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2510917, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2461804, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2253000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2484588, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2269000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2540644, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2445936, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3085135, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2856000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2618722, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2414000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2491143, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2274000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2922215, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2694000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2629738, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2399000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2594812, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2307000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2659726, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2418000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2594235, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2383000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2462050, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2593695, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2325000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s10|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2522319, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2328000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564159, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2315000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518485, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2249000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2568606, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2373000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2517250, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2283000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2509556, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2261000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562131, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2339000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2461472, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2501550, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2279000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2675180, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2400000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2572772, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2279000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2697239, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2286000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2634202, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2389000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2476563, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2580651, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s5|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1750732, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1491000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1814069, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1600000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2553876, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2252000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1740779, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1522000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1868945, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1590000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1739478, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1545000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1954810, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1722000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1706020, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1490000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1837185, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1632000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1894273, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1638000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2002701, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1749000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1680081, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1466000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1898271, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1699000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1855443, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1612000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1838092, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1608000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s5|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1753855, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1403000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1793786, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1579000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1741458, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1495000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1822886, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1598000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2083789, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1880000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2017072, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1822000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1685430, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1504000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1698701, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1511000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1843184, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1611000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1672553, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1456000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1746579, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1558000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1762069, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1507000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1885389, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1645000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2005660, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1712000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1687171, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1448000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s5|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2583055, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2226000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2680663, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2349000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2597510, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2500435, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2276000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2618764, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2370000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2503411, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2282000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2469399, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2263000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2531154, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2482421, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2264000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2469066, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2217000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2547940, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2346000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2461807, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2586655, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2375000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2492272, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2266000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2541585, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s5|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2619313, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2268000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2659232, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2347000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2700678, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2400000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2594453, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2262000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2548124, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2349000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2542705, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2325000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2558445, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2353000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2520768, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2304000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2571408, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2365000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2521608, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2621148, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2394000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2464619, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2254000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2568966, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2318000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2589788, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2377000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2663422, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2458000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s5|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2788332, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2565000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2578841, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2335000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2600950, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2357000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2533753, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2316000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2528928, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2318000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2549849, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2345000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2808319, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2562000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2664966, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2329000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2597385, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2287000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2654610, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2895348, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2671000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2604084, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2347000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2565826, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2585887, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2368000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2516882, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2302000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s5|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2630405, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2290000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2502630, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2276000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2549828, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2322000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2517485, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2543162, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2298000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2620272, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2343000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518455, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2278000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2579511, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2335000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2530156, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2295000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2451437, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2222000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2596592, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2380000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2576580, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2343000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2528446, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2295000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2544176, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2323000, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2563447, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s6|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2603076, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2873039, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2665000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2569116, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2352000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539037, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2302000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2701420, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2496000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s6|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2471682, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2275000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2635593, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2345000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2596120, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2381000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3715498, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 3332000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 4199668, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2830000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s6|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1810563, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1564000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1894185, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1547000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2192408, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1982000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1809284, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1495000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1861638, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1659000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s6|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2219291, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2019000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1853563, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1596000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1763155, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1533000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2180336, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1979000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2096824, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1822000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s6|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2591464, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2379000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2523442, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2317000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2891341, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2652000, + "cpu_system_ns": 0, + "minor_faults": 59, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2695366, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2450000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2465889, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2242000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s6|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2506766, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2308000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2860435, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2609000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2693670, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2484000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2486075, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2872282, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2602000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s4|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2608487, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2383000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2551116, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2304000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2895285, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2698000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2613510, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2365000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2417449, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2217000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2628615, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2425000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2817211, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2624000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468555, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2254000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2598768, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2401000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2482713, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2250000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2440669, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2218000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2830251, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2643000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474173, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2256000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2493706, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2217000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2824494, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2613000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s4|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2598256, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2383000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2423941, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2220000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2620390, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2367000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2875643, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2682000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2399004, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2205000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2564534, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2344000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2451415, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2798015, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2573000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2739788, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2520000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2856701, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2654000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2852665, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2625000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2539779, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2322000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2526822, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2311000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2455980, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2842118, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2654000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s4|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2851586, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2647000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2624733, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2420000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2547247, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2339000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2827802, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2605000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2618890, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2406000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2533471, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2309000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2896316, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2665000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2650423, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2361000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3031248, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2700000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2572874, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2357000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3034020, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2750000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2650667, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2345000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2608576, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2272000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2949525, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2716000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2883763, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2685000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s4|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2619833, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2338000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510447, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2296000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3019183, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2781000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2537159, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2944343, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2729000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2512011, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2836328, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2627000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2535067, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2320000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2507957, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2321000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2808783, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2622000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2588336, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2290000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2469144, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2231000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2822347, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2637000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2521824, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2301000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513067, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2232000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s4|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 2086493, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1829000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1700424, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1504000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2218183, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2029000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1703440, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1512000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1841060, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1641000, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1608287, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1427000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2481076, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2234000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1747326, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1492000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1851662, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1613000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1713648, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1474000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2216435, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2002000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1650909, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1449000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1770493, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1558000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2295449, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1932000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1678943, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1479000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s4|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1797130, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1564000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1623043, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1431000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2170942, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1977000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1623488, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1413000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2122588, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1874000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1639049, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1444000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1823314, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1618000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1742937, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1550000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2207690, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1948000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1574162, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1379000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1808576, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1558000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1684950, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1483000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2156161, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1964000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1839914, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1532000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2009422, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1751000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s1|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2880715, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2655000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2432354, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2583841, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2369000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2540783, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2336000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2435773, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2588718, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2379000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2455612, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2487056, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2648205, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2407000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2550573, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2329000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2485645, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2285000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2597618, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2384000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2491832, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2273000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2500638, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2303000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2593250, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2389000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s1|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2602444, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2463434, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2254000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2664892, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2438000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2464730, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2272000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2442128, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2249000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2585355, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2383000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2444762, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2249000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2453609, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2244000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2628410, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2420000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2508478, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2468945, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2272000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2619511, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2393000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2499981, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2265000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2449418, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2253000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2632515, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2329000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s1|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2535542, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2330000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2536438, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2320000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2506347, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2304000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2458011, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2597688, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2600606, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2397000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2492019, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2268000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2686089, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2475000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2698801, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2487000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2518668, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2291000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2613610, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2417000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2753238, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2549000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2530556, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2660437, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2417000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2879734, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2681000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s1|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2603389, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2403000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2448109, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2236000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2644597, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2443000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2657545, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2470000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2452562, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2205000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2741048, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2544000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2641499, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2439000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2492302, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2216000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2541024, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2313000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2447785, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2240000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2554877, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2320000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2490542, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2276000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2471130, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2238000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2497474, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2314000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2420205, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s1|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1716661, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1487000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1649515, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1463000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1784326, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1519000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1637964, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1438000, + "cpu_system_ns": 0, + "minor_faults": 86, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1673428, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1480000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1662239, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1437000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1601023, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1418000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1831466, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1495000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1637709, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1439000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1715259, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1513000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1660699, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1407000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1695193, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1496000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2915557, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2628000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2023284, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1637000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1822989, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1479000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n15|s1|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1904756, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1574000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1776466, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1450000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2285956, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1937000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1740683, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1435000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1853430, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1554000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1791909, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1430000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2007683, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1691000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1737226, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1398000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2040095, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1725000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1745279, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1422000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1739344, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1444000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1996713, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1527000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1703931, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1391000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1804557, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1468000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1918346, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1568000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s8|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2615646, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2255000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2808355, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2479000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2623815, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2290000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2579417, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2721023, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2369000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2645676, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2299000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2780971, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2424000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2598356, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2645441, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2288000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2524634, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2269000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3175303, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2888000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2471124, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2271000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2393042, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2475067, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2287000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 3008472, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2788000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s8|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2449315, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2263000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2489296, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2301000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2510251, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2314000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2426903, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2228000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2913174, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2704000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2474684, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2290000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2615159, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2410000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2549198, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2342000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2458531, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2262000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2545939, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2335000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2529520, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2439622, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2227000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2540047, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2213000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2538117, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2288000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2427163, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2244000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s8|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2587201, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2348000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2488769, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2298000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2703115, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2460000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2675449, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2473000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2503806, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2312000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2459476, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2233000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2606081, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2393000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2420720, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2215000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2556238, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2212000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2492772, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2292000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2415062, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2562333, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2297000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2520667, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2310000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2492080, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2301000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2570952, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2391000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s8|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2492227, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2277000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2457778, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2709716, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2496000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2500898, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2245000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2500859, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2228000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2684353, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2457000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2513164, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2228000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2530732, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2320000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2480842, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2284000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2440425, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2561024, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2325000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2418338, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2225000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2426132, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2229000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2605424, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2401000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2414195, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2215000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s8|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1738982, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1537000, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1626711, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1434000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1866089, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1650000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1672386, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1470000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1749593, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1548000, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1591874, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1397000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1786983, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1573000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1755620, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1443000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1620145, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1424000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1829244, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1572000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1860559, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1609000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1769908, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1567000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1611815, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1414000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1717680, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1491000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1639031, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1436000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "process-cold|n15|s8|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1960083, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1703000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1795681, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1494000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1864914, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1585000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1778706, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1538000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1803254, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1559000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1726900, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1521000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1642713, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1442000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1678911, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1490000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1617050, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1421000, + "cpu_system_ns": 0, + "minor_faults": 80, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1730725, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1542000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1772274, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1524000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1672639, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1432000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1656104, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1464000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1630586, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1399000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1776696, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1510000, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s1|A|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2526910, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2324000, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2620584, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2408000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2441241, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2243000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2525674, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2324000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2445595, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2258000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s1|A|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2452905, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2257000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2580029, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2336000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2545300, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2319000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2437981, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2228000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2524021, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2295000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s1|B|first", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2498949, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 2302000, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2470563, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2222000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2440988, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2217000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2551343, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2308000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2433102, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2246000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s1|B|second", + "expected_rc": 0, + "samples": [ + { + "elapsed_ns": 2424168, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2199000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2485126, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2303000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2443005, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2217000, + "cpu_system_ns": 0, + "minor_faults": 56, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2453641, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2189000, + "cpu_system_ns": 0, + "minor_faults": 58, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 1, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2482185, + "rc": 0, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 2280000, + "cpu_system_ns": 0, + "minor_faults": 57, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s1|C|first", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1648003, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1457000, + "cpu_system_ns": 0, + "minor_faults": 82, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1680256, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1484000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2044642, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1728000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1649461, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1436000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 2137722, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 0, + "cpu_system_ns": 1875000, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + }, + { + "half": "warm|n5|s1|C|second", + "expected_rc": 2, + "samples": [ + { + "elapsed_ns": 1643850, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1461000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1699018, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1510000, + "cpu_system_ns": 0, + "minor_faults": 85, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1637878, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1457000, + "cpu_system_ns": 0, + "minor_faults": 81, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1723698, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1549000, + "cpu_system_ns": 0, + "minor_faults": 83, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + }, + { + "elapsed_ns": 1679876, + "rc": 2, + "peak_rss_bytes": 27684864, + "rss_unavailable_reason": "", + "cpu_user_ns": 1467000, + "cpu_system_ns": 0, + "minor_faults": 84, + "major_faults": 0, + "voluntary_context_switches": 1, + "involuntary_context_switches": 0, + "accounting_unavailable_reason": "" + } + ] + } + ], + "actual_order": [ + "process-cold|n5|s9|C|first", + "process-cold|n5|s9|C|second", + "process-cold|n5|s9|A|first", + "process-cold|n5|s9|A|second", + "process-cold|n5|s9|B|first", + "process-cold|n5|s9|B|second", + "warm|n5|s10|C|first", + "warm|n5|s10|C|second", + "warm|n5|s10|A|first", + "warm|n5|s10|A|second", + "warm|n5|s10|B|first", + "warm|n5|s10|B|second", + "warm|n5|s9|A|first", + "warm|n5|s9|A|second", + "warm|n5|s9|C|first", + "warm|n5|s9|C|second", + "warm|n5|s9|B|first", + "warm|n5|s9|B|second", + "warm|n5|s4|A|first", + "warm|n5|s4|A|second", + "warm|n5|s4|B|first", + "warm|n5|s4|B|second", + "warm|n5|s4|C|first", + "warm|n5|s4|C|second", + "process-cold|n5|s4|B|first", + "process-cold|n5|s4|B|second", + "process-cold|n5|s4|A|first", + "process-cold|n5|s4|A|second", + "process-cold|n5|s4|C|first", + "process-cold|n5|s4|C|second", + "warm|n15|s8|B|first", + "warm|n15|s8|B|second", + "warm|n15|s8|C|first", + "warm|n15|s8|C|second", + "warm|n15|s8|A|first", + "warm|n15|s8|A|second", + "warm|n15|s2|B|first", + "warm|n15|s2|B|second", + "warm|n15|s2|A|first", + "warm|n15|s2|A|second", + "warm|n15|s2|C|first", + "warm|n15|s2|C|second", + "warm|n5|s2|A|first", + "warm|n5|s2|A|second", + "warm|n5|s2|B|first", + "warm|n5|s2|B|second", + "warm|n5|s2|C|first", + "warm|n5|s2|C|second", + "process-cold|n5|s5|C|first", + "process-cold|n5|s5|C|second", + "process-cold|n5|s5|B|first", + "process-cold|n5|s5|B|second", + "process-cold|n5|s5|A|first", + "process-cold|n5|s5|A|second", + "process-cold|n15|s10|C|first", + "process-cold|n15|s10|C|second", + "process-cold|n15|s10|A|first", + "process-cold|n15|s10|A|second", + "process-cold|n15|s10|B|first", + "process-cold|n15|s10|B|second", + "process-cold|n5|s6|B|first", + "process-cold|n5|s6|B|second", + "process-cold|n5|s6|A|first", + "process-cold|n5|s6|A|second", + "process-cold|n5|s6|C|first", + "process-cold|n5|s6|C|second", + "process-cold|n15|s9|C|first", + "process-cold|n15|s9|C|second", + "process-cold|n15|s9|B|first", + "process-cold|n15|s9|B|second", + "process-cold|n15|s9|A|first", + "process-cold|n15|s9|A|second", + "process-cold|n15|s7|C|first", + "process-cold|n15|s7|C|second", + "process-cold|n15|s7|B|first", + "process-cold|n15|s7|B|second", + "process-cold|n15|s7|A|first", + "process-cold|n15|s7|A|second", + "warm|n15|s6|A|first", + "warm|n15|s6|A|second", + "warm|n15|s6|C|first", + "warm|n15|s6|C|second", + "warm|n15|s6|B|first", + "warm|n15|s6|B|second", + "process-cold|n15|s2|C|first", + "process-cold|n15|s2|C|second", + "process-cold|n15|s2|A|first", + "process-cold|n15|s2|A|second", + "process-cold|n15|s2|B|first", + "process-cold|n15|s2|B|second", + "process-cold|n5|s7|C|first", + "process-cold|n5|s7|C|second", + "process-cold|n5|s7|A|first", + "process-cold|n5|s7|A|second", + "process-cold|n5|s7|B|first", + "process-cold|n5|s7|B|second", + "process-cold|n5|s1|A|first", + "process-cold|n5|s1|A|second", + "process-cold|n5|s1|C|first", + "process-cold|n5|s1|C|second", + "process-cold|n5|s1|B|first", + "process-cold|n5|s1|B|second", + "warm|n5|s7|C|first", + "warm|n5|s7|C|second", + "warm|n5|s7|B|first", + "warm|n5|s7|B|second", + "warm|n5|s7|A|first", + "warm|n5|s7|A|second", + "warm|n15|s9|C|first", + "warm|n15|s9|C|second", + "warm|n15|s9|B|first", + "warm|n15|s9|B|second", + "warm|n15|s9|A|first", + "warm|n15|s9|A|second", + "process-cold|n15|s6|B|first", + "process-cold|n15|s6|B|second", + "process-cold|n15|s6|A|first", + "process-cold|n15|s6|A|second", + "process-cold|n15|s6|C|first", + "process-cold|n15|s6|C|second", + "process-cold|n5|s10|B|first", + "process-cold|n5|s10|B|second", + "process-cold|n5|s10|C|first", + "process-cold|n5|s10|C|second", + "process-cold|n5|s10|A|first", + "process-cold|n5|s10|A|second", + "warm|n5|s8|A|first", + "warm|n5|s8|A|second", + "warm|n5|s8|C|first", + "warm|n5|s8|C|second", + "warm|n5|s8|B|first", + "warm|n5|s8|B|second", + "process-cold|n15|s5|A|first", + "process-cold|n15|s5|A|second", + "process-cold|n15|s5|B|first", + "process-cold|n15|s5|B|second", + "process-cold|n15|s5|C|first", + "process-cold|n15|s5|C|second", + "warm|n15|s3|B|first", + "warm|n15|s3|B|second", + "warm|n15|s3|C|first", + "warm|n15|s3|C|second", + "warm|n15|s3|A|first", + "warm|n15|s3|A|second", + "process-cold|n15|s1|B|first", + "process-cold|n15|s1|B|second", + "process-cold|n15|s1|C|first", + "process-cold|n15|s1|C|second", + "process-cold|n15|s1|A|first", + "process-cold|n15|s1|A|second", + "process-cold|n5|s2|C|first", + "process-cold|n5|s2|C|second", + "process-cold|n5|s2|A|first", + "process-cold|n5|s2|A|second", + "process-cold|n5|s2|B|first", + "process-cold|n5|s2|B|second", + "process-cold|n5|s8|B|first", + "process-cold|n5|s8|B|second", + "process-cold|n5|s8|C|first", + "process-cold|n5|s8|C|second", + "process-cold|n5|s8|A|first", + "process-cold|n5|s8|A|second", + "process-cold|n15|s3|C|first", + "process-cold|n15|s3|C|second", + "process-cold|n15|s3|B|first", + "process-cold|n15|s3|B|second", + "process-cold|n15|s3|A|first", + "process-cold|n15|s3|A|second", + "warm|n15|s7|C|first", + "warm|n15|s7|C|second", + "warm|n15|s7|B|first", + "warm|n15|s7|B|second", + "warm|n15|s7|A|first", + "warm|n15|s7|A|second", + "warm|n5|s5|C|first", + "warm|n5|s5|C|second", + "warm|n5|s5|B|first", + "warm|n5|s5|B|second", + "warm|n5|s5|A|first", + "warm|n5|s5|A|second", + "process-cold|n15|s4|A|first", + "process-cold|n15|s4|A|second", + "process-cold|n15|s4|B|first", + "process-cold|n15|s4|B|second", + "process-cold|n15|s4|C|first", + "process-cold|n15|s4|C|second", + "process-cold|n5|s3|B|first", + "process-cold|n5|s3|B|second", + "process-cold|n5|s3|C|first", + "process-cold|n5|s3|C|second", + "process-cold|n5|s3|A|first", + "process-cold|n5|s3|A|second", + "warm|n5|s3|B|first", + "warm|n5|s3|B|second", + "warm|n5|s3|C|first", + "warm|n5|s3|C|second", + "warm|n5|s3|A|first", + "warm|n5|s3|A|second", + "warm|n15|s10|C|first", + "warm|n15|s10|C|second", + "warm|n15|s10|A|first", + "warm|n15|s10|A|second", + "warm|n15|s10|B|first", + "warm|n15|s10|B|second", + "warm|n15|s5|C|first", + "warm|n15|s5|C|second", + "warm|n15|s5|B|first", + "warm|n15|s5|B|second", + "warm|n15|s5|A|first", + "warm|n15|s5|A|second", + "warm|n5|s6|B|first", + "warm|n5|s6|B|second", + "warm|n5|s6|C|first", + "warm|n5|s6|C|second", + "warm|n5|s6|A|first", + "warm|n5|s6|A|second", + "warm|n15|s4|B|first", + "warm|n15|s4|B|second", + "warm|n15|s4|A|first", + "warm|n15|s4|A|second", + "warm|n15|s4|C|first", + "warm|n15|s4|C|second", + "warm|n15|s1|A|first", + "warm|n15|s1|A|second", + "warm|n15|s1|B|first", + "warm|n15|s1|B|second", + "warm|n15|s1|C|first", + "warm|n15|s1|C|second", + "process-cold|n15|s8|B|first", + "process-cold|n15|s8|B|second", + "process-cold|n15|s8|A|first", + "process-cold|n15|s8|A|second", + "process-cold|n15|s8|C|first", + "process-cold|n15|s8|C|second", + "warm|n5|s1|A|first", + "warm|n5|s1|A|second", + "warm|n5|s1|B|first", + "warm|n5|s1|B|second", + "warm|n5|s1|C|first", + "warm|n5|s1|C|second" + ], + "verdict": "240 halves measured in the preregistered order", + "run_valid": true +} diff --git a/docs/evidence/round7/p022-263a-round7-plan.linux.json b/docs/evidence/round7/p022-263a-round7-plan.linux.json new file mode 100644 index 00000000..ecc280d9 --- /dev/null +++ b/docs/evidence/round7/p022-263a-round7-plan.linux.json @@ -0,0 +1,450 @@ +{ + "tag": "CALIBRATION_ONLY", + "mode": "plan", + "timestamp_utc": "2026-09-11T06:32:25Z", + "work_binding": { + "iterations": 460280, + "helper_sha256": "f937b36bd4dac422f88942b87ea9794e2c75a198a034917e6c02c0abad1c0cbd", + "round6_achieved_median_ms": 2.0128, + "source": "docs/evidence/round6/p022-263a-round6-scales.linux.json", + "target_rung_ms": 2 + }, + "preflight": { + "checks": { + "B1": { + "pass": true, + "symbol_size": 1626024, + "section": ".rodata", + "section_size": 1626056, + "why": "own_round7_padding is 1626024 bytes in .rodata (1626056 bytes)" + }, + "B2": { + "pass": true, + "section": ".rodata", + "segment_vaddr": 8192, + "segment_memsz": 1626276, + "segment_flags": 4, + "why": "the padding lies in SHF_ALLOC section .rodata, wholly inside the PT_LOAD at 0x2000 (1626276 bytes mapped)" + }, + "B3": { + "pass": true, + "arm_b_mapped_bytes": 1628917, + "arm_c_mapped_bytes": 1628892, + "delta_bytes": 25, + "page_bytes": 4096, + "arm_b_file_bytes": 1642152, + "arm_c_file_bytes": 1841648, + "why": "arm B maps 1628917 bytes against arm C's 1628892, a difference of +25 bytes" + }, + "B4": { + "pass": true, + "test": "raw-bytes", + "size": 107, + "sha256": "69126786004d1e128458c1054e6a67a2534397146cf8a4f0d5e838b18fc70797", + "why": "main is 107 bytes and byte-identical in both arms; the disassembly fallback was not needed" + } + }, + "failed": [] + }, + "outcome_preflight": { + "ran": true, + "all_passed": true, + "failed": [], + "arms": { + "A": { + "role": "A", + "pass": true, + "expected_rc": 0, + "observed_rc": 0, + "contract": "exit code only; the helper writes nothing by construction", + "why": "ran 460280 iterations and exited 0", + "stdout_bytes": 0, + "stderr_bytes": 0 + }, + "B": { + "role": "B", + "pass": true, + "expected_rc": 0, + "observed_rc": 0, + "contract": "exit code only; the helper writes nothing by construction", + "why": "ran 460280 iterations and exited 0", + "stdout_bytes": 0, + "stderr_bytes": 0 + }, + "C": { + "role": "C", + "pass": true, + "expected_rc": 2, + "observed_rc": 2, + "contract": "perf_baseline rung 'core-usage': expect_rc [2], evidence 'usage-help'", + "why": "satisfied the instrument's own core-usage contract", + "problems": [] + } + }, + "note": "untimed; no clock was started for any of these probes" + }, + "frozen_arms": { + "A": { + "role": "A", + "name": "arm-a", + "sha256": "f937b36bd4dac422f88942b87ea9794e2c75a198a034917e6c02c0abad1c0cbd", + "file_bytes": 15960 + }, + "B": { + "role": "B", + "name": "arm-b", + "sha256": "0bd6ecc40dfc5c51fbda073fe248d90f6378257e701909d274ea294a742d3c5f", + "file_bytes": 1642152 + }, + "C": { + "role": "C", + "name": "rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "file_bytes": 1841648 + } + }, + "schedule": { + "seed": "0xf937b36bd4dac422", + "seed_source": "first 16 hex digits of helper_sha256 in docs/evidence/round6/p022-263a-round6-scales.linux.json", + "design": "blocked randomisation; block = (regime, n, session)", + "blocks": 40, + "halves": 240, + "regimes": [ + "process-cold", + "warm" + ], + "repetition_counts": [ + 5, + 15 + ], + "sessions_per_cell": 10, + "planned_order": [ + { + "block": "process-cold|n5|s9", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "warm|n5|s10", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "warm|n5|s9", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "warm|n5|s4", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n5|s4", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n15|s8", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n15|s2", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n5|s2", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n5|s5", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s10", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s6", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "process-cold|n15|s9", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s7", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n15|s6", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "process-cold|n15|s2", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s7", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s1", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "warm|n5|s7", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n15|s9", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s6", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "process-cold|n5|s10", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n5|s8", + "arm_order": [ + "A", + "C", + "B" + ] + }, + { + "block": "process-cold|n15|s5", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "warm|n15|s3", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "process-cold|n15|s1", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "process-cold|n5|s2", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "process-cold|n5|s8", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "process-cold|n15|s3", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n15|s7", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n5|s5", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "process-cold|n15|s4", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n5|s3", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n5|s3", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n15|s10", + "arm_order": [ + "C", + "A", + "B" + ] + }, + { + "block": "warm|n15|s5", + "arm_order": [ + "C", + "B", + "A" + ] + }, + { + "block": "warm|n5|s6", + "arm_order": [ + "B", + "C", + "A" + ] + }, + { + "block": "warm|n15|s4", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n15|s1", + "arm_order": [ + "A", + "B", + "C" + ] + }, + { + "block": "process-cold|n15|s8", + "arm_order": [ + "B", + "A", + "C" + ] + }, + { + "block": "warm|n5|s1", + "arm_order": [ + "A", + "B", + "C" + ] + } + ], + "tag": "CALIBRATION_ONLY" + }, + "planned_process_spawns": 2640, + "stop_conditions": [], + "verdict": "PLAN ONLY. Arms built, B1-B4 passed on these exact bytes, identities frozen, execution order fixed. No clock was started and none is authorised: the calibration pass is a separate decision.", + "measurements": null, + "run_valid": true +} diff --git a/docs/evidence/round7/p022-263a-round7-preflight.linux.json b/docs/evidence/round7/p022-263a-round7-preflight.linux.json new file mode 100644 index 00000000..8405d6db --- /dev/null +++ b/docs/evidence/round7/p022-263a-round7-preflight.linux.json @@ -0,0 +1,92 @@ +{ + "tag": "CALIBRATION_ONLY", + "note": "structural preflight only; no clock was started and no timing exists", + "timestamp_utc": "2026-09-11T02:04:09Z", + "sources": { + "spin.c": { + "sha256": "77557875615e1310cce4d36d3f45c21860b7c6250631437e0ee10aead988fa2c", + "bytes": 960 + }, + "pad.c": { + "sha256": "e25f000079cd681ccd1758d4c16e9edd9e248228ca583cd124e6b23e7745c563", + "bytes": 1297 + } + }, + "build": { + "work_object_sha256": "0eccbd873967b200fa20be128dc50d289d9abee14ece5de307b966ec512a453c", + "pad_elements": 203253, + "tuning_trace": [ + { + "pad_elements": 203253, + "mapped_bytes": 1628917, + "delta": 25 + } + ], + "cflags": [ + "-O2" + ] + }, + "arms": { + "A": { + "role": "synth", + "name": "arm-a", + "sha256": "f937b36bd4dac422f88942b87ea9794e2c75a198a034917e6c02c0abad1c0cbd", + "file_bytes": 15960, + "mapped_bytes": 2861, + "pt_load_segments": 4 + }, + "B": { + "role": "synth-padded", + "name": "arm-b", + "sha256": "0bd6ecc40dfc5c51fbda073fe248d90f6378257e701909d274ea294a742d3c5f", + "file_bytes": 1642152, + "mapped_bytes": 1628917, + "pt_load_segments": 4 + }, + "C": { + "role": "core-usage (own-cli)", + "name": "rust/target/release/own-cli", + "sha256": "8f6c06dd7728fdc12663e03dd46b6e32c183656a2a9f9d05b05d1b0f3f9332fe", + "file_bytes": 1841648, + "mapped_bytes": 1628892, + "pt_load_segments": 4 + } + }, + "checks": { + "B1": { + "pass": true, + "symbol_size": 1626024, + "section": ".rodata", + "section_size": 1626056, + "why": "own_round7_padding is 1626024 bytes in .rodata (1626056 bytes)" + }, + "B2": { + "pass": true, + "section": ".rodata", + "segment_vaddr": 8192, + "segment_memsz": 1626276, + "segment_flags": 4, + "why": "the padding lies in SHF_ALLOC section .rodata, wholly inside the PT_LOAD at 0x2000 (1626276 bytes mapped)" + }, + "B3": { + "pass": true, + "arm_b_mapped_bytes": 1628917, + "arm_c_mapped_bytes": 1628892, + "delta_bytes": 25, + "page_bytes": 4096, + "arm_b_file_bytes": 1642152, + "arm_c_file_bytes": 1841648, + "why": "arm B maps 1628917 bytes against arm C's 1628892, a difference of +25 bytes" + }, + "B4": { + "pass": true, + "test": "raw-bytes", + "size": 107, + "sha256": "69126786004d1e128458c1054e6a67a2534397146cf8a4f0d5e838b18fc70797", + "why": "main is 107 bytes and byte-identical in both arms; the disassembly fallback was not needed" + } + }, + "all_passed": true, + "failed": [], + "verdict": "B1-B4 all pass; the round's structural precondition holds" +} diff --git a/docs/evidence/round7/p022-263a-round7-reading.linux.json b/docs/evidence/round7/p022-263a-round7-reading.linux.json new file mode 100644 index 00000000..bd2e6086 --- /dev/null +++ b/docs/evidence/round7/p022-263a-round7-reading.linux.json @@ -0,0 +1,245 @@ +{ + "tag": "CALIBRATION_ONLY", + "readout_of": "docs/evidence/round7/p022-263a-round7-dataset.linux.json", + "D_definition": "D(arm, n, regime) = median across the 10 sessions of |median(second half) - median(first half)| on elapsed_ns", + "drift": { + "process-cold": { + "5": { + "A": { + "D_ns": 62289.5, + "D_ms": 0.0622895, + "per_session_delta_ns": [ + 116862.0, + 10765.0, + 36524.0, + 78394.0, + 260357.0, + 75203.0, + 32735.0, + 139764.0, + 26933.0, + 49376.0 + ] + }, + "B": { + "D_ns": 33730.0, + "D_ms": 0.03373, + "per_session_delta_ns": [ + 49272.0, + 76269.0, + 89290.0, + 18171.0, + 37960.0, + 25174.0, + 29500.0, + 7227.0, + 3172.0, + 159851.0 + ] + }, + "C": { + "D_ns": 51744.5, + "D_ms": 0.0517445, + "per_session_delta_ns": [ + 167438.0, + 14911.0, + 7845.0, + 84091.0, + 142027.0, + 81553.0, + 108769.0, + 5690.0, + 10458.0, + 21936.0 + ] + } + }, + "15": { + "A": { + "D_ns": 32098.5, + "D_ms": 0.0320985, + "per_session_delta_ns": [ + 34903.0, + 97633.0, + 300.0, + 4652.0, + 29294.0, + 107094.0, + 111136.0, + 19808.0, + 7247.0, + 35897.0 + ] + }, + "B": { + "D_ns": 51700.5, + "D_ms": 0.0517005, + "per_session_delta_ns": [ + 29741.0, + 45517.0, + 41915.0, + 121708.0, + 11830.0, + 25501.0, + 57884.0, + 113564.0, + 118611.0, + 73937.0 + ] + }, + "C": { + "D_ns": 34346.5, + "D_ms": 0.0343465, + "per_session_delta_ns": [ + 24931.0, + 23197.0, + 25489.0, + 43204.0, + 75148.0, + 11475.0, + 103689.0, + 8257.0, + 145950.0, + 125942.0 + ] + } + } + }, + "warm": { + "5": { + "A": { + "D_ns": 50943.0, + "D_ms": 0.050943, + "per_session_delta_ns": [ + 1653.0, + 54154.0, + 26564.0, + 47732.0, + 37647.0, + 102206.0, + 475534.0, + 43947.0, + 80264.0, + 130913.0 + ] + }, + "B": { + "D_ns": 44278.0, + "D_ms": 0.044278, + "per_session_delta_ns": [ + 16922.0, + 328252.0, + 34961.0, + 82621.0, + 124083.0, + 32517.0, + 4119.0, + 133663.0, + 53595.0, + 11745.0 + ] + }, + "C": { + "D_ns": 49386.0, + "D_ms": 0.049386, + "per_session_delta_ns": [ + 380.0, + 27265.0, + 240078.0, + 37550.0, + 61222.0, + 235186.0, + 12857.0, + 24290.0, + 149697.0, + 230348.0 + ] + } + }, + "15": { + "A": { + "D_ns": 24307.0, + "D_ms": 0.024307, + "per_session_delta_ns": [ + 40802.0, + 18505.0, + 27209.0, + 113508.0, + 53209.0, + 45536.0, + 6726.0, + 4228.0, + 5845.0, + 21405.0 + ] + }, + "B": { + "D_ns": 48420.0, + "D_ms": 0.04842, + "per_session_delta_ns": [ + 100214.0, + 56586.0, + 18789.0, + 512.0, + 40254.0, + 9524.0, + 141962.0, + 66131.0, + 88503.0, + 31564.0 + ] + }, + "C": { + "D_ns": 90280.5, + "D_ms": 0.0902805, + "per_session_delta_ns": [ + 109364.0, + 18961.0, + 104538.0, + 38083.0, + 76023.0, + 183992.0, + 185287.0, + 435985.0, + 32483.0, + 7700.0 + ] + } + } + } + }, + "outcome": { + "per_regime": { + "process-cold": { + "outcome": "P4", + "why": "P4 held at n=5 and n=15: the witness did not reproduce", + "per_count": { + "5": "P4", + "15": "P4" + } + }, + "warm": { + "outcome": "P5", + "why": "n=5 classified P4 and n=15 classified P5; a rule must hold at both counts within a regime to fire", + "per_count": { + "5": "P4", + "15": "P5" + } + } + }, + "regime_split": true, + "regime_split_reading": "process-cold classified P4 and warm classified P5. This is a cache- and state-sensitivity signal, NOT P5: both regimes spawn a fresh process per iteration and differ only in whether the first two are discarded.", + "tag": "CALIBRATION_ONLY" + }, + "mechanism_attribution": { + "process-cold": { + "applied": false, + "why": "process-cold classified P4; the preregistration applies the mechanism table only after an outcome fires and only to the arm that rule names as elevated" + }, + "warm": { + "applied": false, + "why": "warm classified P5; the preregistration applies the mechanism table only after an outcome fires and only to the arm that rule names as elevated" + } + }, + "not_derived": "no threshold, budget, floor or envelope is derived from any number here; 0.35 is not consulted, reported or compared against; no session was dropped and no run was repeated" +} diff --git a/docs/notes/p022-263a-calibration-policy-proposal.md b/docs/notes/p022-263a-calibration-policy-proposal.md new file mode 100644 index 00000000..6fb02321 --- /dev/null +++ b/docs/notes/p022-263a-calibration-policy-proposal.md @@ -0,0 +1,946 @@ +# P-022 / #263-A — calibration reproducibility policy (revision 5) + +```text +Status: + MECHANISM RATIFIED. + STEPS 1-3 COMPLETE. + STEP 4 DIGEST FREEZE ACCEPTED. + STEP 5 DESIGN CONSTANTS RATIFIED BY THE OWNER AND RECORDED. + STEP 6 TRAINING PREREGISTRATION RECORDED. + NO TRAINING COLLECTION HAS RUN. NO EMPIRICAL CONSTANT IS FITTED. + NO NUMERIC FITTING CORPUS EXISTS. + NO TRAINING OR VALIDATION MEASUREMENT AUTHORISED. +``` + +Revision 4 still opened with "PROPOSAL. Nothing here is ratified" and then, a few +lines down, correctly reported that the statistical architecture and the +`median |Δ elapsed| > 0` precondition had been ratified. A document that +contradicts itself about its own authority is a document whose authority cannot +be read off it, which is a poor property for the artifact a freeze will point at. +The status block above is the whole answer; the title no longer calls it a +proposal. + +This document freezes the *mechanism* by which two calibration runs are judged to +agree. It contains no constant values. Every quantity that will eventually carry +a number is named, given units and a sign convention, and left empty, because a +document that fixes a mechanism and a value in the same breath is a document +where the value was chosen by whoever was holding the pen. + +No clock authority is claimed or implied. No measurement is proposed here. + +## Step 4 — the digest freeze, accepted + +`docs/evidence/calibration/p022-263a-policy-freeze.json` records **which bytes the +policy is**, and nothing else. It carries no design constant, no fitted constant +and no measurement output, because an artifact that carried one would have made +step 4 into step 5 by the convenience of putting two JSON fields next to each +other. + +| field | value | +|---|---| +| `policy_source_commit` | `b4f657a0abdfdfaae199cbc7eee0c47acd8b0057` | +| `policy_source_tree` | `2f49574433fea23f6158f4d8544a3b1543c718d4` | +| `policy_source_root` | `scripts/calibration/` | +| `policy_source_set` | every committed `*.py` recursively under that root, at that commit | +| `policy_implementation_digest` | `c3068ed7fa880a7083866ead25fe8bf65c87889d242d8af1f7eee01582cd5cbf` | +| `measurement_harness_digest` | `562a7f7232dad2f4c79c6adfe0e1e7e25680b4b6f3444d54824bf0405e3c14b3` | + +The source set is physically one file today — `scripts/calibration/policy.py`, +blob `ec3fab8b…`, 25,486 bytes — and the algorithm is nonetheless **recursive over +the root**, not a special case for hashing a single file. A freeze whose formula +silently assumes the current cardinality is a freeze that changes meaning the day +a second module lands. + +**The framing is part of the freeze.** A digest described only in prose is one a +second implementation cannot reproduce, so the byte layout is stated exactly and +stored in the artifact: sha256 over the source set ordered by the UTF-8 bytes of +each repo-relative POSIX path, each file contributing, with no header and no +separator, its path byte length as an 8-byte big-endian unsigned integer, its +path's exact UTF-8 bytes, its blob byte length in the same form, and its exact git +blob bytes. + +`policy_source_files` records every path with its blob sha1 and byte length. It is +not a third identity mechanism: it is the witness list that lets the aggregate +digest be recomputed by anyone holding the repository, without reconstructing what +the author meant. + +**The freeze lives outside the tree it freezes.** An artifact stored under +`scripts/calibration/` would change that tree by existing, and the digest would +then be a claim about a state that no longer exists the moment it is written. + +### What the controls prove, and what they refuse + +`tests/test_calibration_freeze.py` runs seven controls on every CI run, on both +platforms: + +- **`freeze-artifact-shape`** enumerates the entire permitted schema and refuses + anything outside it. It deliberately does *not* list the field names forbidden + today — `q`, `M`, `R_runs`, the ladder, `G`, a fitted `A_abs`/`R_rel`, a + measurement output — because such a list is only ever as complete as the day it + was written. It also requires every number in the document to be a recorded file + byte length, so there is nowhere for a constant to sit even under a permitted + key. `bool` is excluded from "exact count" explicitly: in Python a `bool` is an + `int`, and round 9 of this PR was lost to precisely that. +- **`freeze-ancestry`** proves the frozen source commit is a *strict* ancestor of + HEAD and really carries the recorded tree. +- **`freeze-source-set`** proves the recorded file list is git's own at that commit. +- **`freeze-digest`** recomputes the aggregate from the git blobs at that commit. +- **`freeze-source-unchanged`** proves the freeze commit did not touch the tree it + froze. It compares blob sha1s rather than working-tree bytes, because a CRLF + checkout makes an identical file look different on disk — the round 3 defect. +- **`freeze-harness-untouched`** proves the measurement instrument did not move. +- **`freeze-source-root-clean`** is an addition, not part of the specified freeze. + The selector covers `*.py`; that leaves a gap it does not mention, because a + `constants.json` dropped beside the module would sit under the frozen root, + invisible to the digest, and be a comfortable home for `q`. The digest still + covers exactly `*.py`. This control refuses the gap rather than widening the + selector to paper over it. + +**They refuse rather than degrade.** Each control reads git objects, and where the +objects are absent it reports a refusal instead of a pass it cannot support. The +first draft of that guard refused on *shallowness*, which is a proxy: a shallow +clone can still hold the commit in question, and the development clone does. It +now reads the objects themselves, and the one claim shallowness genuinely blocks — +ancestry — says so in its own message instead of reading as a provenance break. +The CI job that runs these controls therefore checks out with full history. + +## Step 5 — the design constants, chosen by the owner + +`docs/evidence/calibration/p022-263a-design-constants.json` records the five +constants and nothing else. They were **chosen by the owner**, which is the whole +point of the step: a constant this repository picked for itself would be a knob +wearing a ratification. + +| constant | committed form | value | +|---|---|---| +| `q` | `[19, 20]` | 19/20 | +| `M` | `[2, 1]` | 2 | +| `R_runs` | `5` | 5 | +| `N_ladder` | `[5, 15, 45]` | rungs 5, 15, 45, stopping at 45 | +| `G` | `[1, 10]` | 1/10 | + +Rationals are committed as reduced integer pairs and counts as plain integers, +which is the separation revision 4 introduced so that no reader has to decide +whether `15` means the integer or the pair. There is no `N_max`: the ladder's last +rung **is** the mandatory stop, and a second field holding 45 would be a duplicate +free to drift. + +The artifact binds both identities: `policy_implementation_digest c3068ed7fa88…` +and `measurement_harness_digest 562a7f7232da…`. Constants bound to an +implementation other than the frozen one are constants for a policy nobody +reviewed. + +**What is deliberately absent.** No `A_abs`, no `R_rel`, no selected `N`, no +measurement output. Those are fitted rather than chosen, no admissible fitting +corpus exists, and no measurement is authorised. The artifact's schema is +enumerated by a control, so there is no key for one to arrive under. + +**A provenance limit, stated rather than implied.** `ratified_by` records `owner`, +and the repository **cannot check that**. It is an attribution, not a proof, in +exactly the sense the Round 7 reading's withdrawn "checkable" claim was not. What +the repository does establish is the binding: these constants are recorded against +a policy implementation whose bytes are frozen and independently recomputable, so +whatever is later fitted is fitted under constants that were fixed first. + +### The controls + +`tests/test_calibration_constants.py` runs four on every CI run, both platforms: + +- **`constants-artifact-shape`** enumerates the permitted schema, requires rationals + as reduced integer pairs and counts as exact integers, and excludes `bool` + explicitly, since in Python a `bool` is an `int`. +- **`constants-accepted-by-policy`** hands the committed pairs to the frozen + `DesignConstants.from_committed()` and requires an exact round trip through + `as_committed()`. It deliberately does **not** re-state the ranges — `0 < q < 1`, + `M > 1`, `G >= 0`, `R_runs >= 2`, a strictly increasing ladder — because a second + copy of those rules would only prove the two copies agree. The implementation + under freeze is the judge of its own constants. +- **`constants-bound-to-freeze`** requires both recorded digests to equal what step + 4 froze, and the harness digest to equal the live one. +- **`constants-no-empirical`** is a second net whose forbidden names are *derived* + from what `Envelope` serialises, so it grows if the policy grows another + empirical field. **No mutation isolates it**, because the exact schema refuses + every smuggling route one check earlier, and that is recorded rather than + counted as coverage. + +Fifteen mutations, each declaring in advance which control must catch it and +scored only on a `FAIL` line from that control. The count is not the claim: the +claim is that every mutation has a named expected catcher and is scored by output +rather than by a non-zero exit code, so the campaign can grow without the +guarantee changing shape. + +## Revision 5 — what the owner's fourth review changed + +Revision 4 was ruled **CHANGES REQUIRED before the step 4 freeze**, on one P0 in +the implementation and one authority contradiction in this document. Neither +reopens any settled design. + +| finding | fixed in | +|---|---| +| P0 — the exact-arithmetic boundary held at `DesignConstants.from_committed()` and nowhere else, so `Envelope`, `Observation` and `CellObservation` accepted floats, and `Fraction * float` is a float | §2.6 — every quantitative entry point refuses non-exact input, with the new `calib-exact-domain` control | +| authority — the header said "PROPOSAL. Nothing here is ratified" while the body reported the mechanism as ratified | the status block at the top of this document | + +The P0 was real and worse than it reads: driven rather than argued, a float +entering through a dataclass made the **fitted `R_rel`** a float, along with the +bound and the comparison that decides the verdict. A module that had refused a +floating-point LP solver on exactness grounds was admitting floats through the +front door. + +A float is now **refused, never converted**: `Fraction(0.1)` preserves the binary +error with impeccable fidelity, which removes nothing. An `int` is refused too — +it is exact, but `int / int` is a float in Python, so admitting it leaves a float +one ordinary division away. + +## Revision 4 — what the owner's third review changed + +Revision 3 was ruled **PASS WITH TWO MECHANICAL CORRECTIONS**, with the +statistical architecture **RATIFIED**. The owner also **ratified the +`median |Δ elapsed| > 0` precondition** that revision 3 had flagged as an +addition they might strike: without it the `work` rule has the same structural +zero-hole (`0 ≥ 0.5 × 0`) and reports a CPU mechanism where no wall-clock drift +exists at all. The value is structural, not empirical: if the quantity being +explained is zero, mechanism attribution has no subject. + +| finding | fixed in | +|---|---| +| P0 — "no constant defaults" named only `q`, `M`, `G`, `A_abs`, `R_rel` as required arguments, so an implementation could hard-code `R_runs` or the `N` ladder without contradicting the sentence | §3.6 — one immutable `DesignConstants` carrying **all five** design constants, required, no defaults | +| P1 — §3.2 required every design constant in canonical *rational* form, but `R_runs` and the ladder's elements are semantically **counts** | §2.6 — representation split by kind: rationals as reduced pairs, counts as canonical integers | + +Nothing else is reopened. The owner ratified the symmetric midpoint comparison, +the hybrid envelope, the exact quantile regression, the pooled fitting, the +four-way semantics, the no-`K` aggregation, the holdout firewall and the per-`N` +stratification with deterministic `N` selection as **settled**. + +## Revision 3 — what the owner's second review changed + +Revision 2 was ruled **PASS WITH MECHANICAL CORRECTIONS**: the statistical +architecture accepted, the mechanism not yet ratified, on two P0 findings and two +P1. + +| finding | fixed in | +|---|---| +| P0 — exact arithmetic never said how a design constant is *written down*, so one implementation could read a decimal as a float and another as a rational | §2.6 — a canonical exact-rational representation, and a refusal for anything else | +| P0 — the sequence let the implementation be written after the training data existed, which is a steering surface even with the prose frozen | §3.6 — the implementation, its controls and its frozen digest all precede the training collection | +| P1 — the tie-break rationale claimed more than the rule guarantees | §3.3 — the claim is **withdrawn** with a counterexample; the rule stands as canonicalisation only | +| P1 — `N_max` duplicated the last element of a finite frozen ladder and could contradict it | removed throughout; the ladder's last element **is** the mandatory stop | + +Nothing else is reopened. The owner ratified the symmetric midpoint comparison, +the hybrid form, the quantile regression, the pooling, the four-way semantics, +the no-`K` aggregation, the holdout firewall and the per-`N` stratification as +settled, and reopening a settled choice is its own kind of drift. + +## Revision 2 — what the owner's first review changed + +Revision 1 was ruled **CHANGES REQUIRED** with four P0 findings and one P1. The +form was ratified in principle; the mechanism was not, because a reasonable +statistical plan is not the same object as a single computable function, and the +space between those two is where knobs hide. + +| finding | fixed in | +|---|---| +| P0 — the verdict universe contradicted itself: §1 declared three verdicts, §2.5 used a fourth | §1, §2.4, §2.5, §4, §8 — the set is now **four-way** throughout | +| P0 — the numeric training corpus mixed instruments: stale halves and `historical/` artifacts belong to superseded harness and identity contracts | §3.1 — a hard current-harness firewall, and §3.5, which states the uncomfortable consequence | +| P0 — the fit of `A_abs`/`R_rel`/`q`/`M` was under-specified: two reasonable people could implement it differently and both claim to have followed the document | §3.2 and §3.3 — empirical and design constants separated, and a complete enumerable algorithm | +| P0 — `N` selection was mathematically undefined: the model has no `N` in it | §3.4 — per-`N` envelopes and a deterministic selection rule | +| P1 — §6.3 inherited constants without naming their provenance | §6.3 — the source artifact, the digest that covers it, and why this policy may not touch them | + +Three things were **not** reopened in revision 2 either: the symmetric midpoint +comparison, the hybrid absolute-plus-relative form, and the no-`K` aggregation. + +## Why this document exists, in the frozen brief's own terms + +§13 asks for an instrument, a `CALIBRATION_ONLY` validation report and a fresh +exact-head PASS. All three exist. But §7 requires a mechanical noise and outlier +policy fixed **in advance** together with a determinism check, and §9 says a +second run on the same environment must reproduce within that policy — otherwise +the instrument is **not yet frozen**. + +The repository's own record says it does not: the committed sizing pairs do not +reproduce reliably, the report-of-record glob is empty, and `n=5` has passed and +failed on this machine in no pattern. The blockage is therefore not a missing +file with the right name. **We need an instrument that says compatible things +twice**, and a mechanical definition of "compatible" fixed before it is applied. + +## 1. The object of admissibility + +The policy decides exactly one question, about exactly one kind of input: + +> Given **two calibration runs** of the **same instrument** on the **same +> environment** over the **same cell universe**, is the pair `reproducible`, +> `not-reproducible`, `inconclusive`, or `invalid`? + +It does **not** decide whether any engine is fast enough, whether a change is a +regression, or whether any workload meets any budget. Those are D7 questions and +§7 keeps them behind a different freeze. + +### The verdict set is four-way, at both levels + +The same four names apply to a **cell** and to a **run pair**, and no other name +may appear anywhere in the policy, the implementation, or a report. + +| verdict | meaning | +|---|---| +| `reproducible` | comparable, and the observed change is within the frozen inner bound | +| `not-reproducible` | comparable, and the observed change is outside the frozen **outer** bound | +| `inconclusive` | comparable, and the change lies between the inner and outer bounds | +| `invalid` | **not comparable**; no statement about agreement is available at all | + +`invalid` is not a bad score. It is a refusal to score, and it must never be +reported as a failure to reproduce — an incomparable pair says nothing about the +instrument, and calling it a failure invites fixing it by re-running. + +`not-reproducible` is the statistical failure. Keeping it distinct from `invalid` +is what lets §4's holdout branch mean something: only one of those two outcomes +is evidence about the instrument. + +## 2. The frozen form + +### 2.1 Statistic and granularity + +- **Granularity: the cell** — the existing four-part identity + `(rung, engine, workload, regime)`. No coarser, so a well-behaved cell cannot + average away a badly behaved one; no finer, so nothing new must be recorded. +- **Statistic: the cell's median** of its retained samples, in nanoseconds — the + quantity the instrument already computes and commits as `median_ns`. +- **Retention** is governed by §6 and by nothing else. + +### 2.2 The comparison must be symmetric, and today it is not + +Reproducibility is a **symmetric relation**. The incumbent rule is not. It +computes `|m_B − m_A| / m_A`, dividing by whichever run happened to be recorded +first. For tolerance `T` and ratio `r = m_B / m_A`, the forward direction refuses +when `r > 1 + T` and the reversed direction when `r > 1 / (1 − T)`. Since +`1/(1 − T) > 1 + T` for every `T > 0`, there is always a non-empty band + + 1 + T < r < 1 / (1 − T) + +in which **the verdict depends on which run was recorded first**. That is a +property of the form, true for every positive tolerance, independent of the +incumbent constant's value, and verified exhaustively rather than asserted. + +No committed verdict is known to sit in that band, and this document deliberately +does **not** go looking: hunting through recorded pairs for one that flips is +selection on outcome wearing a lab coat. + +**The replacement is symmetric in both terms:** + + Δ(c) = |m_B(c) − m_A(c)| the observed change + t(c) = (m_A(c) + m_B(c)) / 2 the reference duration + bound(t) = A_abs + R_rel · t the inner bound + +`t` is the midpoint precisely so that swapping the runs changes nothing. Either +run alone reintroduces the asymmetry; the minimum makes the bound depend on which +run was slower, which is the same disease. + +### 2.3 Why hybrid, and the honesty cost of saying so + +A purely relative bound applies one fraction across a population spanning three +orders of magnitude. Round 6's exploratory reading — formally **O3, +inconclusive**, licensing nothing — observed that relative shift rises sharply at +the short end while absolute drift does not stay constant either. + +So the hybrid form is **chosen on data that has already been seen**. That is +permitted for choosing a *form* and forbidden for fixing *constants*, which is +the entire reason §3.1's firewall and §4's holdout exist. If the form is wrong, +the holdout is what will say so, and the response is §4, not a better fit. + +`A_abs` carries nanoseconds. `R_rel` is dimensionless. Neither has a value here. + +### 2.4 The per-cell rule, and its inequalities + + cell invalid (see §6.4) → cell `invalid` + Δ(c) ≤ bound(t(c)) → cell `reproducible` + Δ(c) > M · bound(t(c)) → cell `not-reproducible` + otherwise → cell `inconclusive` + +with `M > 1` a single dimensionless widening factor defining the outer bound. One +factor rather than a second independent pair of constants, because every extra +constant is another place a result can be steered. + +The inequalities are fixed here and are not adjustable: the reproducible branch +is **inclusive** (`≤`) and the refusing branch is **strict** (`>`). A value +landing exactly on a boundary is decided by the written rule, never by a rounding +direction. All comparisons are performed in **exact rational arithmetic**, as +`classify.py` already does, so an edge is decided by the rule rather than by +binary floating point. + +### 2.5 Aggregation: precedence, never counting + +A run pair's verdict is determined by strict precedence over its cells: + +1. any cell `invalid`, or any pair-level invalidating condition in §6 → pair **`invalid`** +2. else any cell `not-reproducible` → pair **`not-reproducible`** +3. else any cell `inconclusive` → pair **`inconclusive`** +4. else → pair **`reproducible`** + +**There is deliberately no tolerated-failure count.** A rule of the form "at most +`K` cells may fail" introduces a constant whose only function is to decide how +much disagreement to forgive, and it will be adjusted the first time `K + 1` +cells fail. The multiplicity problem this creates is real and is named rather +than solved by a knob: requiring every cell to agree over a large universe is a +strict family-wise condition, and the correct response is a bound that honestly +describes the instrument's own dispersion, not a budget of permitted failures. If +that proves impossible, the honest outcome is a failed policy under §4 and a +conversation with the owner, not a `K` that grows until the gate opens. + +### 2.6 How a constant is written down + +Revision 2 insisted on exact rational arithmetic and then left the constants as +"a dimensionless number", which settles nothing: a value written as a decimal — +say `0.95`, used here only as an illustration and not as a proposed value — is +read by one implementation as a binary float and by another as `19/20`, and the +two then disagree on every boundary case. That is a particularly silly gap in a document that already +refused a floating-point LP solver on exactness grounds. + +**Every rational quantity in this policy — design constant, empirical constant, +and every intermediate — is represented canonically as a pair of integers:** + + numerator, denominator + denominator > 0 + gcd(|numerator|, denominator) = 1 + +The reduced form with a positive denominator is unique, so the representation is +itself canonical and two implementations cannot disagree about what was frozen. + +Binding consequences: + +- a constant is **committed as that integer pair**, never as a decimal string and + never as a float +- reading, writing or comparing any of these quantities through a binary + floating-point value is a **refusal**, not a rounding difference +- the admissible ranges are expressed on the pair: `q` in `(0, 1)` means + `0 < numerator < denominator`; `M > 1` means `numerator > denominator > 0`; + `G ≥ 0` means `numerator ≥ 0` +- `A_abs` is a rational count of nanoseconds in the same canonical form. It is + not rounded to an integer: rounding it would be an undeclared adjustment to a + bound, in whichever direction the rounding happened to go + +**Counts are not rationals, and are not written as though they were.** Revision 3 +required *every* design constant in the reduced-pair form, which would have left +a reader working out whether `N = 15` is the pair `(15, 1)` or the integer `15`. +Representation is therefore fixed **by kind**: + +| quantity | canonical form | +|---|---| +| `q`, `M`, `G` | reduced rational pair, denominator `> 0` | +| `A_abs(N)`, `R_rel(N)` | reduced rational pair, denominator `> 0` | +| `R_runs` | a canonical **integer**, `≥ 2` | +| the `N` ladder | a finite, ordered list of canonical **positive integers** | + +This is a serialization and provenance correction. It changes no statistic, no +rule and no boundary. + +## 3. How the constants will be obtained + +### 3.1 Three corpora, and a firewall between them + +**Form evidence** — already-seen data. It may motivate or select the model +**form** and **may not contribute numerically to any fitted constant**: + +- the Round 6 ladder and dataset +- the Round 7 dataset +- the four committed sizing halves, stale and marked stale +- the preserved pre-contract artifacts under `docs/evidence/historical/` + +**Numeric fitting corpus** — must satisfy **all** of: + +- produced under the **exact current harness digest** +- produced under the **current identity contract** +- produced under the **current outcome contract** +- drawn from a **named calibration-only workload universe**, named in the + training preregistration before collection, containing no decisive workload + +**Validation corpus** — fresh, **disjoint** from the fitting corpus, collected +only **after** the constants are frozen and committed. + +Why the firewall is drawn at the harness digest and not at "it came out of the +same stopwatch": Round 7 is a process-shape A/B/C experiment, not a repeated +calibration population; the stale halves were recorded under superseded harness +identities. Measuring soup with a thermometer does not calibrate it for a child. +A number came out, technically. + +Using the fitting corpus to fit and then citing it as independent evidence that +the policy works is the single move this document exists to make impossible. + +### 3.2 Two kinds of constants, with different origins + +Revision 1 put all six in one table, which hid the fact that they come from +different places. `q` in particular cannot be "fixed by the fitting procedure", +because `q` is what *tells* the fitting procedure which quantile to estimate; +saying otherwise was circular. + +**Empirical constants** — derived from the fitting corpus by the deterministic +estimator in §3.3: + +| name | unit | meaning | +|---|---|---| +| `A_abs` | nanoseconds | the duration-independent part of the inner bound | +| `R_rel` | dimensionless | the duration-proportional part | + +**Design constants** — **owner decisions**, ratified with a stated rationale, and +**frozen before the fitting corpus is collected**, not merely before the fit. +Freezing them only before the fit would still let them be chosen to flatter data +already in hand. + +| name | unit | what it decides | +|---|---|---| +| `q` | quantile level in `(0, 1)` | which quantile of the instrument's dispersion the inner bound claims to cover | +| `M` | dimensionless, `> 1` | the width of the inconclusive band, as the outer bound's multiple of the inner | +| `R_runs` | count, `≥ 2` | how many repeated runs per cell the fitting corpus collects | +| the `N` ladder | a **finite**, ordered, frozen list of counts | the repetition counts the instrument may use; **its last element is the mandatory stop**, and there is no separate maximum — a second knob there would express nothing but a future argument about which maximum wins | +| `G` | dimensionless, `≥ 0` | the diminishing-returns margin used by §3.4 to select `N` | + +No design constant may be derived from the fitting corpus, none has a value here, +and each is written in the canonical exact-rational form of §2.6 when it is +eventually ratified. + +### 3.3 The empirical fit, specified as a single computable function + +The response and predictor, fixed: + +- the fitting corpus yields, per cell, `R_runs` runs in recorded order +- an **observation** is a **consecutive** run pair `(k, k+1)`, giving `R_runs − 1` + observations per cell. Consecutive rather than all pairs, because all-pairs + observations are not independent and would silently over-weight cells, and + because a second run following a first is exactly what §9 tests +- for each observation: `y = |m_{k+1} − m_k|` and `t = (m_k + m_{k+1}) / 2`, + the same `Δ` and `t` that §2.2 uses at verdict time +- **within one ladder rung, the observations from every cell in the named + universe `U` are pooled into a single fit.** One envelope per rung, not one per + cell: a per-cell envelope would have as many constant pairs as cells and would + fit each cell's own noise, which is how a bound stops being a bound +- all arithmetic is exact rational + +Given the frozen `q`, the constants are the solution of a **non-negative linear +quantile regression**: + + minimise L(a, r) = Σ_i ρ_q( y_i − (a + r · t_i) ) + subject to a ≥ 0 , r ≥ 0 + where ρ_q(u) = q · u for u ≥ 0 + ρ_q(u) = (q − 1) · u for u < 0 + +A bound must not be negative anywhere on the duration range, which is what the +two constraints say. + +**The solution is found by exact vertex enumeration, not by a numerical solver.** +A floating-point LP solver is not reproducible across platforms or library +versions, and this policy must produce identical constants from identical bytes +on Linux and on Windows. The objective is piecewise-linear and convex and the +feasible region is a polyhedron, so an optimum is attained where **two** of the +following conditions are active: + +- a residual condition `a + r · t_i = y_i` for some observation `i` +- the bound `a = 0` +- the bound `r = 0` + +The candidate set is therefore finite and enumerable: + +1. for every pair of observations `i < j` with `t_i ≠ t_j`, the line through both: + `r = (y_j − y_i) / (t_j − t_i)`, `a = y_i − r · t_i` +2. for every observation with `t_i ≠ 0`, the point `a = 0`, `r = y_i / t_i` +3. for every observation, the point `r = 0`, `a = y_i` +4. the corner `a = 0`, `r = 0` + +Candidates violating `a ≥ 0` or `r ≥ 0` are discarded. `L` is evaluated exactly +at each survivor and the minimum is taken. + +**The tie-break is load-bearing, not ceremony.** The optimum of a quantile +regression need not be unique — an entire face of the polyhedron can attain it. +Over three hundred randomly generated datasets, the optimum was non-unique in +thirty-four of them, and the tied solutions disagreed in the intercept by a wide +margin. Without a stated tie-break, two correct implementations of this document +would return materially different constants and both would be entitled to say +they followed it. That is precisely the defect this revision exists to remove. + +**Tie-break, in order.** Among all objective minimisers represented by the +enumerated candidate set: + +1. choose the smallest `A_abs`; +2. among those, choose the smallest `R_rel`. + +This is a deterministic **canonicalisation** rule. It does not claim pointwise +dominance over every other minimiser. Its purpose is identical constants from +identical corpus bytes, and that is the whole of its purpose. + +**A claim about this rule is withdrawn.** Revision 2 asserted that "a tie is +never resolved in the direction that makes the gate easier to pass". That is +false, and not merely overstated. Tied optima need not share a slope, so a +smaller intercept can come with a steeper one, and the two lines cross. A +concrete witness, found by search rather than argued: observations +`(t, y) = (8, 20), (8, 10), (3, 11)` at `q = 1/2` have two tied minimisers at +equal loss — `A_abs = 28/5, R_rel = 9/5` and `A_abs = 11, R_rel = 0`. The rule +selects the first, which is **looser** than the second for every `t > 3`. + +The moral is the one this project keeps paying for: a rule may be perfectly good +at its actual job while the sentence justifying it quietly promises something +else. The rule stays; the promise goes. And no scalar tie-break by envelope area +or summed width replaces it, because that would introduce a second objective +nobody asked for, on top of the one that already decides. + +**Fail-closed conditions of the fit**, each refusing rather than guessing: + +- fewer than two distinct `t` values in the corpus → the two-parameter model is + not identifiable; refuse +- any observation with a non-finite or negative `y` → refuse; `y` is an absolute + difference and cannot be negative +- an empty candidate set after the feasibility filter → refuse + +### 3.4 Selecting `N`, with `N` actually in the model + +Revision 1 required choosing the smallest `N` whose *predicted dispersion* fell +within `bound(t)`, while the model `A_abs + R_rel · t` contains no `N` at all. +There was nothing to predict with. The finding is accepted without reservation. + +**The rejected repair** is to give the model a closed-form `N`-dependence — a +`1/√N` term, say. That would import the assumption that the dominant variability +is sampling uncertainty of the median, which is exactly the proposition Round 6 +declined to establish and named as its own alternative. A functional form nobody +has evidence for is not a repair; it is the same missing knowledge written in +mathematical notation. + +**The adopted repair:** `N` enters as a **stratum**, not a parameter. + +- the fitting corpus is collected at **every** `N` on the preregistered ladder +- §3.3 is run **independently per `N`**, yielding one frozen envelope per rung: + `E_N(t) = A_abs(N) + R_rel(N) · t` +- define each cell's reference duration at that rung as the **median of that + cell's `R_runs` recorded medians**, written `t_c(N)`. A cell has several + medians in the fitting corpus, so "the cell's duration" is otherwise not a + single number, and a rule that does not say which one is a rule two + implementations will answer differently +- define the scalar width of a rung over the named calibration workload universe + `U`: + + W(N) = Σ over c in U of E_N( t_c(N) ) + +- let `W_min` be the smallest `W(N)` over the ladder +- **select the smallest `N` on the ladder with `W(N) ≤ (1 + G) · W_min`** + +This is deterministic, consumes only the fitting corpus, and never touches +validation data. It is well defined: the rung achieving `W_min` always satisfies +the inequality for any `G ≥ 0`, so a selection always exists and there is no +undefined branch. + +It also cannot become escalate-until-pass. `N` is fixed **before** the validation +pair exists, from training evidence alone, and is not revisited afterwards. The +forbidden rule — "the smallest `N` at which the pair reproduces" — turns the stop +rule into a starting gun, and is why this section exists in this form. + +`A_abs(N)`, `R_rel(N)` and the selected `N` are all committed together before §4 +begins. + +### 3.5 The uncomfortable consequence: no admissible fitting corpus exists today + +§3.1's firewall, applied honestly to what this repository holds, says that +**there is currently no admissible numerical fitting corpus** for this policy +under the current harness identity. Everything on hand is form evidence. + +This is a normal outcome, not a setback, and the response is not to squeeze +constants out of the museum exhibit in `historical/`. + +### 3.6 The implementation is written before the data, not after + +Revision 2 jumped from a ratified mechanism straight to a measurement, leaving +the code that applies the policy to be written afterwards. That is a steering +surface even when the prose is frozen: an implementation written with the +training data already on disk can be nudged, in a hundred defensible small ways, +toward the answer its author has already seen. + +So the implementation, its controls and its **frozen digest** all precede the +training collection. And its provenance is not softer than the instrument's: +**code that decides admissibility must not have weaker provenance than code that +starts the stopwatch.** + +- if the implementation changes `perf_baseline.py` or any source covered by the + **measurement-harness digest**, that digest moves — necessarily **before** any + training data exists, never after +- if it lives separately and the harness is untouched, that is equally fine, but + its **own digest becomes a mandatory identity axis** for the fit, for the + constant freeze and for the validation pair, exactly as the harness digest is + +The required sequence, each numbered step a separate owner decision: + +```text + 1. mechanism RATIFIED (docs only; this document) + 2. implement pure policy / fitter / verdict (NO constant defaults anywhere) + 3. mutation + control review, exact-head CI (the implementation's own adversary) + 4. freeze policy-implementation digest + AND measurement-harness digest (both, before any corpus exists) + 5. ratify the exact-rational design constants + q, M, R_runs, the finite N ladder, G (owner decision; no data consulted) + 6. preregister the numeric training collection, + bound to BOTH frozen digests (before it is run) + 7. separate authority -> ONE training collection (a measurement) + 8. deterministic fit per rung, select N per §3.4 (no new data) + 9. freeze the empirical constants (committed) +10. commit the fresh holdout protocol (before any validation data) +11. separate authority -> ONE validation pair (a measurement) +12. four-way verdict per §4 +``` + +Step 2 carries **no constant defaults**, and that has to cover the whole design +set rather than the constants that happen to appear in a formula. Revision 3 +named only `q`, `M`, `G`, `A_abs` and `R_rel`, which left an implementation free +to hard-code `R_runs` or the `N` ladder without contradicting a word of it — and +those two decide the corpus cardinality and the `N` selection outright. That is +precisely the steering surface this section exists to remove. + +**All five design constants travel together in one immutable object**, required, +with no default anywhere: + +```text +DesignConstants + q reduced rational pair, 0 < numerator < denominator + M reduced rational pair, numerator > denominator > 0 + R_runs canonical integer, >= 2 + N_ladder finite ordered list of canonical positive integers + G reduced rational pair, numerator >= 0 +``` + +Who consumes what, so that no argument is carried merely for symmetry: + +- the **fitter** uses and validates `q`, `R_runs` and `N_ladder` +- the **selector** uses `G` +- the **verdict** uses `M` +- `A_abs(N)` and `R_rel(N)` are the fitter's **empirical outputs** and the + verdict's **required inputs**; they are never design constants and never + carry a default either + +No dormant parameters are added for the sake of a tidy signature. + +Steps 7 and 11 are measurements and neither is authorised by this document. +Step 5 precedes step 6 deliberately: design constants chosen after seeing the +training corpus would be design constants chosen to flatter it. + +## 4. The holdout firewall + +After the mechanism is frozen, the design constants are ratified, and the +empirical constants are frozen by §3.3 and §3.4, and **before** any validation +measurement exists, a validation protocol is committed fixing: + +- the environment, by the recorded fingerprint of §6.5 +- the cell universe +- the selected `N` and the warmup discards +- that the pair is **exactly two runs**, recorded back to back +- that both halves are committed, whatever the verdict +- the verdict procedure, which is §2 applied mechanically + +Then it is run **once**. + +| holdout verdict | consequence | +|---|---| +| `reproducible` | §8's gate may proceed | +| `inconclusive` | reported as inconclusive; the gate does **not** open | +| `not-reproducible` | **FAILED POLICY**, returned to the owner with the evidence | +| `invalid` | the pair was not comparable; diagnose the incomparability, do **not** rescore it | + +**On `not-reproducible` the constants are not adjusted.** Not widened, not +refitted, not re-estimated with the new data folded in. Refitting after seeing +the holdout is tolerance shopping in a good suit, and it is the exact failure +mode this entire PR was built to prevent. + +A second validation pair requires separate authorisation, and a policy that +needed several attempts must say so in its own record. + +## 5. What the instrument already fixes, carried forward unchanged + +- **Warmup discards** are a policy default, not a knob. The source comment records + why: warmup was once moved from two to three alongside a repetitions escalation + that had been authorised on its own, turning one permitted knob into two turned + after seeing which runs went red. +- **Pair identity** is the existing ten-axis contract, and a mismatch raises + rather than reporting a verdict. +- **Outcome identity precedes timing.** Two runs agreeing to the nanosecond while + exiting differently reproduced a coincidence, not a measurement. +- **Both halves of a pair are committed**, each naming the other, so a verdict can + be recomputed instead of trusted. + +## 6. The complete §7 contract + +Every item carries an explicit decision, including an explicit "none". A silently +absent policy is the thing §7 forbids. + +### 6.1 Warmup discards + +Per regime, fixed in advance, enforced by a control, not tunable per run. The +current values are already policy and are carried forward unchanged. + +### 6.2 Trimming and winsorizing: **none** + +An explicit decision, not an omission. No trimmed mean, no winsorizing, no +outlier rejection of any kind on retained samples. + +Every trimming rule carries a constant — how much to cut — and that constant is a +place to steer from. The statistic is already the median, robust without +discarding anything, and a sample that is genuinely wrong is the business of +§6.4's invalidating conditions, which refuse the run rather than quietly +improving it. + +### 6.3 Noise floor, and the provenance of its inherited constants + +The opening and closing noise probes are carried forward as **run-invalidating +conditions**, not as reproducibility conditions. They bound dispersion within one +probe and drift between the opening and closing probes. They are different +statistical quantities from the reproducibility bound and are **not** refitted by +§3. + +**Provenance, stated exactly**, because "carried forward" in a document that +claims to contain no numbers otherwise invites the later question of whether +these were new constants or merely already lying about: + +- **Where they live:** `NOISE_PROBE_MAX_RELATIVE_IQR` and `NOISE_PROBE_MAX_DRIFT` + in `scripts/perf_baseline.py`, together with `DEFAULT_WARMUP_DISCARDS` and + `DEFAULT_CALIBRATION_REPETITIONS`. +- **What covers them:** the content-addressed **harness digest**, `562a7f7232da` + at this head. Those constants are part of the hashed instrument sources, so the + digest is a commitment to their values. +- **Who froze them:** they are incumbent ratified policy, in force before this + document existed, and D7's C1 freezes the harness digest that covers them. +- **Why this policy may not change them:** changing any of them **moves the + harness digest**, which stales every pair ever recorded against the old value + and un-compares every future number from every recorded one. A reproducibility + policy that silently re-based the instrument while defining reproducibility + would be worse than no policy. + +This document therefore **inherits** them and does not introduce, re-derive or +propose values for them. Their retirement or replacement is a separate owner +decision with its own re-record cost, and is out of scope here. + +### 6.4 Invalidating conditions, at two levels + +§2.4 and §2.5 both consume this section, and they consume different halves of it, +so both are stated. + +**Cell-level — the cell is `invalid` and is never scored:** + +- the cell's recorded outcome is not valid in either run +- the two runs disagree about the cell's observed exit code or outcome validity; + they did not measure the same thing, so their durations are not comparable +- the cell produced no median in either run +- the cell is present in one run and absent from the other + +**Pair-level — the whole pair is `invalid`, whatever its cells say:** + +- an identity contract breach — the candidate, the arms, or the harness digest + moved during either run +- an outcome contract breach — any spawn exited outside its declared contract +- a noise probe outside §6.3 +- an environment fingerprint mismatch under §6.5 +- a required cell missing, unknown, or named twice in either run +- a recorded field absent where the platform should have produced it + +Each condition names itself in the record, with the cell or spawn that triggered +it, and the run leaves a durable artifact saying so. + +### 6.5 Same environment + +A pair is comparable only if both halves carry the identical **environment +fingerprint**: the existing ten pair-identity axes plus the recorded machine and +OS identity. + +A fingerprint mismatch makes the pair `invalid`, **never** `not-reproducible`. +The instrument cannot cryptographically prove two runs happened on one machine; +it can record what it observed, and it must refuse rather than guess. + +A GitHub-hosted Windows runner is already recorded as not measurement-grade — two +runs minutes apart on one commit disagreed about their own environment — so the +environment must be named explicitly in §4's protocol and in the step 6 training +preregistration. + +### 6.6 Determinism and the re-run rule + +The verdict function is pure: same two committed reports in, same verdict out, +recomputable by anyone from committed evidence. No clock, no network, no +filesystem state, no randomness. + +The **fitting** procedure is equally pure: same corpus bytes in, same +`(A_abs, R_rel)` out, on any platform, by §3.3's exact enumeration and tie-break. + +§9's re-run rule is satisfied by §4's validation pair and by nothing else. In +particular it is **not** satisfied by any pair already in the repository, all of +which predate this policy and most of which predate the current harness identity. + +## 7. Separation from D7, stated as a rule + +| this policy decides | this policy never decides | +|---|---| +| whether two calibration runs agree | whether any engine is fast enough | +| whether the instrument may be frozen | any performance budget or regression bound | +| which `N` the instrument uses | any G3 metric's pass or fail | +| when a run is invalid | anything about a decisive workload | + +Three binding consequences: + +1. No constant defined by this policy may be read by, copied into, or derived + from any D7 threshold, and none may be used as one. +2. The output of this policy is **never** an input to a G3 verdict. It gates the + instrument, not the result. +3. The incumbent reproducibility constant is **not** carried forward by + assumption. It remains in force until §3 freezes a replacement and §4 + validates it; its retirement is then an owner decision, recorded. + +## 8. The gate + +```text +policy mechanism frozen (this document, ratified) + ↓ +pure implementation written, mutation-reviewed, CI green + ↓ +policy-implementation digest AND measurement-harness digest frozen + ↓ +design constants ratified as exact rationals (§2.6, §3.2; no data consulted) + ↓ +training collection preregistered against both digests, authorised, run once + ↓ +empirical constants frozen per rung, N selected (§3.3, §3.4; deterministic) + ↓ +validation protocol committed (§4; before any validation data) + ↓ +ONE fresh validation pair + ↓ +four-way verdict under §2 and the §6 contract + reproducible inconclusive / not-reproducible / invalid + ↓ ↓ + #263-A PASS owner decision / redesign + (constants are NOT adjusted) +``` + +## 9. Every constant, with no value + +**Empirical — output of §3.3, one pair per ladder rung:** + +| name | unit | fixed by | +|---|---|---| +| `A_abs(N)` | nanoseconds | §3.3, from the fitting corpus at rung `N` | +| `R_rel(N)` | dimensionless | §3.3, from the fitting corpus at rung `N` | + +**Design — owner decisions under §3.2, frozen before any corpus is collected:** + +| name | unit | fixed by | +|---|---|---| +| `q` | quantile level in `(0, 1)` | owner ratification | +| `M` | dimensionless, `> 1` | owner ratification | +| `R_runs` | count, `≥ 2` | owner ratification | +| the `N` ladder | finite ordered list of counts; last element is the mandatory stop | owner ratification | +| `G` | dimensionless, `≥ 0` | owner ratification | + +**Inherited — not set, not re-derived, not proposed here:** the noise-probe +limits, the warmup discards and the default calibration repetitions, all covered +by harness digest `562a7f7232da` per §6.3. + +No numbers. If a later revision contains a value that did not come from §3.3 or +from a recorded owner ratification, that value was invented, and these tables are +where it will be visible. + +## 10. What this proposal does not do + +It does not authorise any measurement — not the training collection at step 7, +not the validation pair at step 11. Steps 2 and 3 are done and step 4, the +digest freeze, is the next thing awaiting the owner's word; this document does +not grant it. It does not re-record the stale sizing pairs, promote a +calibration of record, freeze D7, unblock #263-B, merge, or start Stage 3 or +Stage 4. It does not move any incumbent constant, and it still contains no +values. + +It does not claim the instrument is frozen. It is a plan to find out, and every +number it will eventually need is still missing on purpose. diff --git a/docs/notes/p022-263a-instrument.md b/docs/notes/p022-263a-instrument.md new file mode 100644 index 00000000..d77ff29c --- /dev/null +++ b/docs/notes/p022-263a-instrument.md @@ -0,0 +1,1616 @@ +# #263-A — the measurement instrument (calibration only) + +**What this is.** The frozen *instrument* for #263's P-022 performance baselines: +how a number is produced, never what the number should be. It permits building +the harness and running **calibration**. It does not authorize the decisive +measurement (#263-B, gated by the D7 freeze) and it sets **no** thresholds, no +repetition count `N`, and no Rust-vs-Python comparison statistic. Those are D7's, +preregistered before the decisive run. + +**Baseline.** Built on `main` = `ca8b1064fc6ac5e0a901d8b67eb9f2bbd3543fd5`. +Stage 1 and Stage 2 of #262 are closed; Stage 3/4 are unauthorized. + +- instrument: `scripts/perf_baseline.py` +- frozen workloads: `docs/evidence/p022-263a-workloads.json` +- controls: `tests/test_perf_instrument.py` +- calibration reports: `docs/evidence/p022-263a-calibration..json` + +--- + +## 1. Preflight reconciliation, against primary source + +Read from `origin/main` at the baseline: live #263, and #262's **Performance +gates** section. + +**#262's Performance gates name seven phases:** process startup; OwnIR parse; +bridge/lowering; analysis; CLI/SARIF rendering; end-to-end C# project/solution +run; peak RSS/allocations where practical. + +**The brief's §1 adds one:** frontend/Roslyn extraction, explicitly *recorded but +not D7-gated* unless the owner separately ratifies a gate. The two lists +reconcile: §1 = #262's gate list + extraction as a diagnostic phase, so an +end-to-end regression can be localised instead of reported as "something +happened between `git checkout` and SARIF". + +**The two populations, frozen.** + +| | what it is | does it enter the D7 cutover verdict? | +|---|---|---| +| **A — G3 cutover subset** | #262's Performance-gate phases | yes — these feed D7 | +| **B — IDE-foundation remainder** | frontend extraction, no-op recheck, single-file edit recheck, diagnostic-publication latency proxy, IDE budgets | **no**, unless separately owner-ratified | + +Completing #263-A must not silently narrow #263's own acceptance. Recorded here +so the narrowing cannot happen by omission — **#263 asks for measurements this +instrument does not yet take**, and they are owed on population B's own track: + +- `.own` workloads: minimal file, medium module, corpus batch; +- OwnIR **serialization** (this instrument measures parse, which is #262's gate + phase; serialization is #263's broader list); +- no-op recheck, single-file edit recheck, diagnostic-publication latency proxy; +- allocation/heap profile; +- explicit IDE latency budgets (a *budget* is a threshold and is therefore not + #263-A's to propose at all). + +## 2. What is, and is not, separately observable + +Neither engine exposes per-phase timing through its production surface, and +#263-A is not authorized to add production instrumentation. So the instrument +measures a **ladder of real production invocations**, records each as the +composed interval it actually is, and names the phases inside it. Where a phase +cannot be isolated it is recorded as `composed` or `unavailable` — #263 asks for +unavailable stages to be *marked*, not imputed. + +| rung | surface | interval contains | observability | +|---|---|---|---| +| `core-usage` | core | core startup + argv parsing + usage refusal | composed — a **lower bound** on startup, not startup | +| `core-parse-refused` | core | startup + read + parse + door refusal | composed | +| `core-full-human` | core | startup + parse + bridge + analysis + human render | composed | +| `core-full-sarif` | core | startup + parse + bridge + analysis + SARIF render | composed | +| `launcher-e2e` | launcher | launcher startup + extraction + core + render | composed | + +Each rung also declares the **exit codes that mean it did its job** and a +post-condition proving it: `core-usage` 2 with the driver banner on stdout and +nothing on stderr; `core-parse-refused` 2 with the refusal on stderr and nothing +on stdout; `core-full-*` 0 or 1 (1 is "leaks found", not a failure) with a +rendered verdict; `launcher-e2e` 0 with a verdict. The post-condition runs +**once, untimed, with output captured**, so its cost never reaches a benchmark. +A cell whose invocation did not do the rung's work **is not timed at all** and +the calibration is refused. + +**`launcher-extract` was withdrawn.** It invoked the launcher with +`--emit-facts` and was documented as "no core runs, so this isolates the +frontend stage". The launcher says otherwise: `--emit-facts` copies the +intermediate facts and then Stage 2 runs the engine anyway. The interval +therefore contained the whole pipeline while recording itself as launcher +startup plus extraction — the same defect as the old `core-usage` label, one +level up. Isolating launcher-scoped extraction would need either a production +launcher change or a direct extractor invocation, and a direct extractor process +is *not* the launcher's extraction stage. So it is recorded **unavailable** +rather than invented, and `frontend-extraction` stays measured as a member of +`launcher-e2e`. + +**The ladder floor is a bound, not a phase.** `core-usage` is the smallest +invocation the production surface allows: the process starts, parses argv, finds +no document, writes a usage refusal and exits. Calling that interval "startup" +would be convenient and wrong — argv handling and refusal rendering are inside +it, and nothing in either production surface separates them out. So it is +recorded as `composed` over `process-startup-core` + `cli-argv-parse` + +`cli-usage-refusal`, and +what it gives D7 is a **lower bound** on core startup. + +**A phase list means "this interval did these things".** One name once covered +two actions — argv parsing *and* the usage refusal — and so appeared on three +rungs that never write a usage refusal. The report copied that taxonomy +faithfully and the control compared the two and agreed they matched, which is +how a schema stays self-consistent while saying something false. The vocabulary +now separates `cli-argv-parse` (every real core invocation), `cli-usage-refusal` +(only the floor rung) and `ownir-door-refusal` (only the version-refused rung), +and a refusal phase may appear only on the rung whose **outcome evidence proves +that refusal happened** — `cli-usage-refusal` ⇔ `usage-help`, +`ownir-door-refusal` ⇔ `door-refusal`, and neither on a rung that reaches a +verdict. + +Applying the same rule the other way, `launcher-e2e` now also names +`process-startup-core` and `cli-argv-parse`: the launcher spawns the core, so +those actions are genuinely inside that interval and a complete list has to say +so. + +**Derived views are labelled as derived and never presented as measurements.** +`core-parse-refused − core-usage` does *not* yield parse: it yields the ownir +read+parse cost only under an assumption this instrument never measures — that +both invocations pay the same argv handling and comparably priced refusal +rendering. It is a derived **bound**. Likewise `core-full-sarif − +core-full-human` is a *renderer difference*, which is not the same quantity as +rendering in isolation. + +**`bridge-lowering` and `analysis` are not separately observable** through either +production surface. They are recorded as members of the `core-full-*` interval. +Isolating them needs production instrumentation this brief does not authorize — +recorded as an instrument limitation rather than worked around. + +**Two startups, never merged.** `process-startup-core` (the child engine) and +`process-startup-launcher` (what a user actually waits for) are separate +metrics, because merging them would let the user-visible number absorb the +child's. + +## 3. Same input — which means two different things + +**Isolated core rungs:** one OwnIR byte sequence, its sha256 recorded, the *same +bytes* handed to Python and to Rust. + +**End-to-end:** the same pinned source tree, configuration and extractor +identity — and **each engine performs its own extraction**, inside the elapsed +time. An end-to-end number that shares one extraction between engines is a core +comparison wearing an end-to-end hat. The Rust end-to-end path goes **through +the production launcher** selecting Rust, never `own-cli` substituted for the +user-visible path. + +The candidate is the production `own-cli`, built deterministically, sha256 and +byte length recorded. Never `own-shadow-engine`, never a stub. + +## 4. Workloads + +Frozen in `docs/evidence/p022-263a-workloads.json`, in two populations that +cannot be confused because the calibration set is **generated** by the harness +rather than found on disk. + +- **Decisive** (13): the committed sample/examples/corpus trees, the five pinned + OSS repositories of #243 at their verified pins (repo walk and largest + solution, which is a different extractor path and a differently *ordered* + document, not a subset), and #262's large-solution control — declared under its + own id and recorded as an **alias** so it is never counted twice. +- **Calibration** (6): generated facts documents at three scales, a document the + strict door refuses, and two synthetic C# trees. + +Drift on a pinned target is a **failed target**, never a newer measurement. + +## 5. Environment matrix + +Linux **and** Windows; they differ in exactly the mechanics — process launch, +filesystem, path forms — that a single-platform baseline leaves unproven. +Recorded per run: CPU model and core count, RAM, OS, .NET SDK, Python, Rust +toolchain, runner class. + +## 6. Cold and warm + +- **process-cold** — a fresh process every iteration, no in-process warmup. The + default: cheap, portable, and honestly named. +- **warm** — steady state after a stated number of **discarded** warmup + iterations, never averaged in. The process is still fresh; what is warm is the + OS and filesystem cache. +- **machine/cache-cold** — **not claimed.** It exists only behind a documented + reset protocol (cache drop, reboot, fresh VM), and "caches not pre-warmed" + with no reset step means a different kind of cold on Windows than on Linux. A + machine-cold claim without its reset protocol is inadmissible, so the + instrument does not make one. + +## 7. Repetitions, aggregation, and what is deliberately absent + +Each engine's own samples are summarised as **median + dispersion (IQR and MAD) ++ min**, never mean-only. Raw per-iteration data is retained: an aggregate whose +raw is gone cannot be re-audited. + +**Not here, on purpose:** + +- the decisive `N` and its escalation ladder — D7 preregisters them from + calibration variance; the calibration repetition count in a report is an + instrument-sizing parameter and is labelled as one; +- the **Rust-vs-Python comparison statistic** — ratio of medians and median of + paired ratios are not the same thing, and choosing between them is a decision. + The instrument enforces this structurally: every cell holds exactly one + engine's samples, and a report carrying a comparison key is refused on the way + out. + +## 8. Noise, outliers, invalidation + +A fixed deterministic task is timed at the start and end of every session. Its +dispersion is the **noise floor**; exceeding it, or drifting between the opening +and closing probes, **invalidates the run** rather than widening the reported +dispersion — a benchmark that absorbs contention into its error bars is +reporting the noise as if it were the subject. The floor is an +*instrument-validity* constant: it says how much the machine may wobble, and +nothing whatever about either engine. + +**Reproducibility** (§9) is checked by re-running and comparing each cell's +median against the earlier run, to `REPRODUCIBILITY_MAX_MEDIAN_CHANGE`. That is +a **chosen** policy constant, not one derived from the run: this section used to +claim it came from "the noise floor the earlier run itself recorded" and so +"tightens on a quiet machine", and neither was true — the recorded limit *was* +the constant, and it never tightened. What makes it admissible is that it was +chosen before the runs it judges. See §7 for the three policies it was split +into. **Both halves of every pair are committed**, and run B records run A's +path and sha256, so the verdict can be recomputed from evidence rather than +trusted. + +## 9. Peak RSS + +By a named mechanism, recorded, never eyeballed: + +- POSIX: `os.wait4` — the kernel's per-child `ru_maxrss`, for exactly the + process spawned. Chosen over `/usr/bin/time -v` as primary because GNU time is + a package that may simply be absent, and "the tool was missing" is not a + memory measurement. `/usr/bin/time -v` remains the documented fallback. +- Windows: a Job Object, `PeakProcessMemoryUsed` via `QueryInformationJobObject`. + +Where nothing is available the value is `null` **with a reason**, so a silent +absence can never be read as a measured zero. Allocation counts are not yet +captured — recorded as owed on population B's track rather than quietly dropped. + +On POSIX the same `wait4` call also carries the child's CPU split, fault counts +and context-switch counts. Those are now kept rather than discarded — see *The +interval kept its meaning and gave up its secrets* — under the same rule: off +POSIX they are `null` with a reason, never zero. + +## 10. The CALIBRATION_ONLY firewall + +Every calibration result is tagged `CALIBRATION_ONLY`, is not decision evidence, +and cannot choose a threshold. + +Before the D7 freeze a **decisive** workload may be enumerated, hashed, fetched, +availability-checked, and exercised by **non-timed structural smoke** — nothing +else. The instrument is deliberately **stricter than "no paired runs"**: a +single-engine timed run of a decisive workload is refused too, because a +stopwatch appears nowhere in that permitted list. + +The prohibition is structural, not clerical. There is exactly **one** function +that starts a clock and it refuses a decisive workload unless the identity gate +is armed. "We did not save the delta" is accounting-clean and epistemically +worthless: whoever watched the two numbers has already peeked, and every +threshold chosen afterwards is a rationalisation with a timestamp. + +## 11. The D7-freeze gate + +#263-A permits calibration and does **not** authorize the decisive run. There is +no continuous slide from one into the other: the freeze is a discrete gate with +a before and an after, and #263-B may not begin until it has passed. + +## 12. The single-reference rule + +Every result records the Python reference **commit SHA** alongside the +interpreter version, so a later artifact cannot silently combine comparisons +bound to two different reference states. The preferred path is that the +V1/V2/invalid-UTF-8 hygiene lands **before** the D7 freeze and #263-B. + +## 13. The four carried obligations + +| | obligation | where it lives | +|---|---|---| +| (a) | the identity gate exists **now**, dormant | `IdentityGate`; built before the instrument is final, because D7's C1 freezes the harness digest and a gate added after that freeze makes this a different instrument | +| (b) | arming is **data only** | two committed JSON objects — a freeze payload and a detached ratification; no source patch, so the control proves the harness digest does not move when the gate arms and that the firewall then opens. Fixtures use the **production nested layout**, because the first set put both objects at the repository root, where a wrong path model is accidentally right | +| (c) | **fail-closed, before any measured interval** | identity verification completes and passes first; a control counts both digest computations and git invocations *inside* a measured interval and requires zero of each — a gate that pays for itself out of the startup benchmark is a defect wearing a safeguard's coat | +| (d) | **two identity domains, kept apart** | the C1/C2 gate covers reference + harness + manifest + D7 payload; the **session** identity covers the candidate binary, frozen at session start, and its drift refuses the remainder of the session. The candidate is the thing under test, so it is not instrument identity | + +### What the gate actually verifies + +D7 §6 defines **two git commits**, not two sections of one file. + +| | | +|---|---| +| **C1** | the immutable payload commit — thresholds/rules/rollups, the Python reference sha, the #263-A tree sha, harness digest and version, the workload manifest digest, and the owner's ratification | +| **C2** | a detached attestation in a **descendant** commit — the payload's commit sha, its blob sha, the sha256 of its **exact bytes**, the instrument/reference/workload bindings, and the ratification binding | + +An earlier implementation used the same two letters for something else: `c1` and +`c2` were sections *inside* one payload, with `c2` holding threshold values. The +word had quietly changed profession, and an equivalent-looking scheme is not the +frozen scheme. It had no equivalent at all of `payload_blob_sha`, of exact-byte +hashing, or of the ancestry requirement. + +The verifier now proves, in order: the payload declares its kind and schema and +carries every required field; its protocol section is **present and never read** +(those values are thresholds); its bindings equal what this process observes; a +detached attestation exists, declares its own kind, and is complete; its +`payload_sha256` equals the sha256 of the payload's **exact bytes**, not a +canonical re-serialisation; its `payload_blob_sha` equals the payload's git blob +at `payload_commit_sha`, and the working-tree bytes are that blob; its own +commit is a **strict descendant** of the payload commit; and its bindings and +ratification binding equal the payload's. + +**One guard is defensive and untested.** A same-commit state — where the +attestation's `payload_commit_sha` names the commit that contains the +attestation — cannot be constructed with ordinary git, because the attestation +would have to contain the sha of a commit whose sha depends on the attestation. +The guard stays, because "cannot currently be built" is not "cannot exist", and +it is recorded here as untested rather than faked with a mocked git. + +### The Python reference is not `HEAD` + +`python_reference_commit()` returned `git rev-parse HEAD`. That is not the +reference; it is wherever the repository happens to be standing. Every commit +moved it, evidence-only commits included, which is how run A and run B of one +pair recorded two different "reference" identities while `ownlang` had not +changed a byte. + +Worse at D7: the freeze creates a C1 commit and then a C2 commit, so a correctly +executed freeze would itself invalidate the reference binding it had just +written down. An alarm that counts its own installation as a break-in. + +The reference commit is now the last commit that **touched the reference +source**, and a `python_reference_tree` records that source's content-addressed +git tree object beside it. The commit sha names a label; the tree object shows +two artifacts saw the same bytes. Both are in `PAIR_IDENTITY_FIELDS`. + +### The anchor is provenance, not the current position + +`IdentityGate.observe()` computed `instrument_tree_sha = git rev-parse HEAD` and +C1 was required to equal it. That check can never pass in production, and the +reason is written on the lifecycle itself: + + S (the accepted #263-A tree) + -> C1 the payload commit + -> C2 the detached attestation commit + -> #263-B runs here + +By the time #263-B runs, HEAD is at least C2. It is not S and cannot be made to +be S. Writing the future C2 sha into C1 in advance is not a workaround, it is +asking a content-addressed commit to contain a value that determines it. + +The defect is doubly embarrassing because the fix for its twin is three lines +away and argued in full: `python_reference_commit()` stopped being +`git rev-parse HEAD` in the previous round precisely because "a correctly +executed freeze would itself invalidate the reference binding it had just +written down". The same sentence was true of `instrument_tree_sha` and it went +unread. + +So the anchor is now **declared by C1 and proved by content**: + +| | | +|---|---| +| declared | `instrument_anchor_commit` — S, the accepted #263-A source commit | +| proved | the instrument **at S** hashes to the `harness_digest` C1 froze | +| proved | S is an ancestor of C1 | +| never required | that HEAD equal S, C1 or C2 | + +The rest of the chain was already proved: C1 is a strict ancestor of C2, and C2 +is located by `git log` in HEAD's own history. So `S <= C1 < C2 <= HEAD` falls +out without asserting a position anywhere. Because the workload manifest is one +of the `INSTRUMENT_SOURCES`, proving the harness digest at S also proves the +manifest at S — there is no second anchor check to write and no second anchor +check to get wrong. + +`harness_digest()` reads the working tree and `harness_digest_at()` reads git +blobs at a commit, and the anchor proof compares one against the other. They +therefore share **one** formula, `_harness_digest_from`. Two implementations of +"the same" formula would make that proof a comparison of two functions, and +their agreement would mean nothing. + +#### Why the fixtures could not see it + +`_build_freeze` committed a README and two JSON files into a throwaway +repository, and took `observed` from the **real** one. The payload was therefore +built from the same HEAD the gate then compared it against, and the single thing +the production lifecycle does between acceptance and #263-B — move HEAD past S — +could not happen. The fixture isolated production from exactly the effect it +existed to check, which is the third time in this PR that a green control has +proved only what it was asked to prove. + +The fixture now commits the real `INSTRUMENT_SOURCES` at S, does ordinary work, +freezes C1 and C2, and then **keeps committing**. `perf-gate-arms-by-data` +asserts that the anchor, C1, C2 and HEAD are four distinct commits, so if the +fixture ever stops reproducing a moving repository the control says so instead +of quietly passing. Reinstating `anchor must equal HEAD` makes a valid freeze be +refused, which is the regression test for the original defect. + +### A preregistration is not three strings + +C1's protocol was three key names checked for presence, and the fixture that +proved the check worked armed the gate with + + thresholds = "" + rules = "" + rollups = "" + +Two immaculate git commits, three celebratory strings, and the decisive firewall +opens. + +The gate still must never **read** a threshold — a #263-A artifact that quoted +one would leak the number this module exists to keep out — but that says nothing +about whether the preregistration is *there*. Those are different questions and +only one of them was being asked. C1 now has to carry, per cell: + +| | | +|---|---| +| `dimensions` | `phase`, `workload_id`, `platform`, `regime` — all four | +| the rule | `bound`, `pass_fail_rule`, `inconclusive_band`, `comparison_statistic`, `rss_policy`, `allocation_policy` | +| `repetition_ladder` | `initial_n`, `escalation_stages`, `transition_predicates`, `max_n`, `terminal_outcome` | +| or | an explicit `not_applicable` **with a stated reason** | + +and roll-ups at all three preregistered levels: `workload_class`, `phase`, +`overall_g3`. A bare `not_applicable: true` is refused, because it is a way of +writing "no rule" that reads like a rule. + +`_present()` inspects presence and container shape only. A blank string, an +empty list and an empty object are structurally absent however confidently they +are typed. Nothing compares, orders, or records a value, so no threshold can +leak through the verifier — and the fixture's own cells are filled with +deliberately non-production placeholders, because a fixture that only passed +with plausible *numbers* would prove the gate reads thresholds. + +Every message names the field it is about, so each of the ten new damaged +freezes is matched to the check that owns it. One broad "malformed protocol" +refusal would let a dozen missing checks hide behind a single passing case. + +**Completeness was recorded here as not implementable, and that was wrong.** See +the next section: the decisive population is knowable before the freeze, and +checking that every cell was decided selects nothing. + +### `not_applicable: true` was accepted, and the PR said it was not + +`_present()` returned `value is not None` for anything that was not a string, +list or dict. In Python a `bool` is an `int`, so: + + _present(True) -> True + _present(False) -> True + +Both `{"not_applicable": true}` and `{"not_applicable": false}` passed a check +whose entire purpose was to demand a **stated reason**. The PR description +asserted that a bare `true` was refused. It was not, and I had written that +sentence without testing it — a claim about a guard, published, untested, in the +same document that argues a green gate proves only what it was asked to prove. + +Two repairs, because the boolean hole is a class and not an instance: + +- `_present()` now rejects `bool` outright, checked **before** `int` since a + bool is one. A yes/no is never a preregistered decision, for any field. +- `not_applicable` must be a **non-empty string**. A reason in words, or the + cell is not decided. + +And a cell may no longer be both: carrying `not_applicable` alongside any rule +field is refused, because a preregistration that is simultaneously applicable +and inapplicable is not a decision, it is a superposition. + +### A payload that decided half a percent of the experiment + +The verifier checked every cell it was handed and never asked whether it had +been handed them all. D7 does not say "at least one well-formed cell"; it says +**for every applicable (phase × workload-id × platform × cold/warm regime) +cell**. So a payload with one immaculate cell and three roll-up strings passed. + +The old fixture demonstrated the hole rather than catching it: `_valid_payload` +carried three synthetic cells and armed the gate. + +`expected_d7_cells()` now enumerates the universe from data the instrument +already holds: + +| axis | source | count | +|---|---|---| +| phase | the frozen `PHASES` taxonomy | 11 | +| workload id | the frozen decisive manifest, **aliases resolved** | 12 | +| platform | `D7_PLATFORMS` | 2 | +| regime | `D7_REGIMES` | 2 | +| | **cells D7 must decide** | **528** | + +The gate refuses a payload with any cell **missing**, any cell **unknown**, or +any dimension tuple named **twice**. Each expected cell needs a complete rule or +an explicit `not_applicable` with a reason. + +Three things this deliberately does *not* do. It does not read a value, so no +threshold passes through it. It does not decide applicability — the payload does +that, and the gate only proves the owner decided *something* about every cell. +And it does not enumerate over the running platform: the universe covers **both** +platforms wherever the gate runs, because #263-B runs on both and a Linux gate +demanding only Linux cells would let half the experiment through unfrozen. + +**The alias earns no second vote.** `large-solution-control` is `alias_of` +`oss-ShareX.sln` — the same path at the same pin, declared under its own id +because #262's gate names it, and recorded as an alias precisely so it is never +counted twice in a denominator. `canonical_workload_id()` resolves it, so the +two ids are one cell; a payload naming both for the same phase/platform/regime +is refused as a duplicate. A completeness check that missed this would have +turned a double-counting safeguard into a double-counting machine. + +**Why this is knowable before the freeze, and not a threshold decision.** The +brief permits enumerating, hashing and availability-checking decisive workloads +before D7 and forbids only performance exposure. It has to permit it: if the +decisive population were not known before D7, D7 could not be written. Nothing +here selects a budget, an `N`, or a tolerance. An earlier revision of this note +argued that completeness "needs the decisive cell population" and recorded it as +not implementable — that was wrong, and it was wrong in the convenient +direction. + +### The completeness check proved the wrong set + +The previous round built the expected universe from `PHASES`. That is the +**attribution** taxonomy — it answers "what did this timed interval contain", so +a rung can be described honestly. It is not D7's vocabulary, and using one as +the other produced a universe that was wrong in both directions at once: + +| | | +|---|---| +| demanded | a preregistered rule for `cli-argv-parse`, `cli-usage-refusal`, `ownir-door-refusal` and `frontend-extraction` on every workload, platform and regime | +| omitted | the **end-to-end C# run**, one of the metrics the G3 verdict weighs most, which has no entry in `PHASES` at all because it is a *rung*, not a part | + +The code had already said so and was not listened to. The accept fixture keyed +its not-applicable slice on `phase == "frontend-extraction"`, auto-excusing all +48 of those cells — the instrument admitting they were never D7's business while +the universe went on requiring them. A check that manufactures an obligation and +then ceremonially forgives it is not a check, it is paperwork. + +`D7_PHASES` is now separate from `PHASES`, and the relationship between them is +**data**, not coincidence: + +| set | meaning | +|---|---| +| `D7_PHASES` | the 8 G3 cutover metrics a rule is preregistered for | +| `D7_NON_METRIC_PHASES` | attribution components that are **not** gates, each with the reason recorded | +| `D7_METRICS_WITHOUT_PHASE` | a D7 metric with no single attribution phase — `end-to-end-csharp` is the launcher-e2e rung's whole interval | + +`d7_vocabulary_problems()` enforces that every attribution phase is either +promoted to a metric or explicitly excluded **with a reason**. Neither is a +default, so a phase added to `PHASES` later cannot silently join or silently +miss the D7 universe. It runs in `--selftest` as well as in a control, because +the failure mode is drift rather than a wrong line. + +The universe is now 8 metrics x 12 canonical decisive workloads x +2 platforms x 2 regimes = **384** cells. + +**The names were provisional; they are now RATIFIED.** They were written down as +provisional because the defect being fixed here is exactly what happens when an +implementation label is left to become a normative contract by default. + +The owner has since ratified the mapping against the frozen +`prompt-263A-measurement-design-4.md`, the final D7 brief and live #262, at exact +head `0374793`: + +| ratified as a D7 metric | why | +|---|---| +| `process-startup-core`, `process-startup-launcher` | frozen #263-A makes child-core startup and public-launcher startup **two** metrics, not one | +| `ownir-parse`, `bridge-lowering`, `analysis` | G3 performance phases named in the frozen text | +| `render-human`, `render-sarif` | the frozen "CLI/SARIF rendering" item, as its two concrete surface metrics | +| `end-to-end-csharp` | the whole user-visible rung, correctly separate from the attribution parts it contains | + +| ratified as NOT a D7 metric | why | +|---|---| +| `cli-argv-parse`, `cli-usage-refusal`, `ownir-door-refusal` | attribution taxonomy only | +| `frontend-extraction` | diagnostic population B, excluded by the frozen #263-A itself | + +The denominator is ratified with them: **8 metrics x 12 canonical decisive +workloads x 2 platforms x 2 regimes = 384**. The manifest carries 13 decisive +entries, but `large-solution-control` is an alias of `oss-ShareX.sln`, so the +canonical count is 12. Ratifying 384 does **not** mean 384 numeric budgets: an +explicit `not_applicable` with a reason remains a legitimate decision for a +cell. What it means is that the owner must now decide about each one rather than +lose it between two lists. + +**The source comment still reads "NAMES ARE PROVISIONAL", deliberately.** At the +commit that wrote it, they were. Editing it now would move the harness digest, +stale both pairs and force an eleventh re-record — relabelling the fire +extinguisher and re-calibrating the laboratory because of it. The ratification +binds here, in the ledger, and to the exact head it was given at. + +RSS and allocation deliberately stay per-cell policies rather than becoming a +phase axis; the frozen schema already models them that way. + +### The Python reference boundary, closed by observation + +`python_reference_commit` and `python_reference_tree` content-address exactly +`PYTHON_REFERENCE_PATH` — `ownlang/`. That is only an honest identity if the +reference's behaviour is confined to what it names. If the measured path read a +schema, a rule table or a config from elsewhere in the repository, the reference +could change behaviour without changing its own sha, which is the same defect +class as an identity that names the checkout. + +Settled by observing rather than arguing. An audit hook records every file the +reference OPENS and every process it spawns, on both render surfaces: + +| | human | sarif | +|---|---|---| +| repository files opened **outside** `ownlang/` | **0** | **0** | +| processes spawned | **none** | **none** | +| `ownlang/` modules loaded on the measured path | 18 | 18 | + +Three further routes were checked and are closed: + +- **Static imports.** `ownlang` imports the standard library and itself, nothing + else in the tree. +- **Config.** `ownlang/config.py` states it explicitly: no auto-discovery, no + environment variables, no per-path overrides — a config enters only through an + explicit `--config`, which no rung passes. A file consulted-if-present would + be `stat`ed rather than opened and would slip past an audit; there is no such + file to slip. +- **Subprocesses.** The `fix_*` repair pipeline does spawn processes, but none of + it is loaded on the measured path. + +`perf-reference-boundary` keeps this proven rather than asserted, and is +mutation-verified in both directions: a probe that opens `pyproject.toml`, or +spawns `/bin/true`, fails the control. + +#### The one residual, not fixed here + +`OWNLANG_DEBUG` is read by `ownlang/__main__.py`, and the instrument passes the +ambient environment through unchanged. It affects only the internal-error path — +on a successful run the branch is never taken, so it cannot alter analysis +output — and when it does fire it returns 70, which no rung declares, so the +outcome contract refuses the cell rather than timing it. It is therefore +**fail-closed**, but it is still an uncontrolled input that the reference +identity does not cover. + +**Since fixed, batched with the mypy work** — both edits move the harness digest, +so doing them together costs one staleness event instead of two. +`REFERENCE_ENV_PINNED_UNSET` names the variables the reference reads that its +content-addressed identity does not cover, and every measured invocation clears +them. The same reference source can no longer behave two ways depending on the +shell it was launched from. + +### The instrument is type-checked now + +`scripts/perf_baseline.py` was outside `mypy`'s file list, so "Success, 43 files" +never covered the file that produces the numbers. It is in the list now — 44 +files — and passes `--strict`. + +The 42 errors it exposed were almost entirely one root cause: values parsed from +JSON are `object`, and the code called `.get()`, `int()` or `float()` on them +behind `x or {}` idioms with `# type: ignore` comments that had drifted to the +wrong error codes. Four narrowing helpers — `_as_obj`, `_as_list`, `_as_int`, +`_as_float` — say it once, to the reader and the checker at the same time. + +They narrow in the **fail-closed** direction. A non-object where an object +belongs becomes empty, so the caller's own completeness check refuses it, rather +than raising an `AttributeError` three frames from the cause. `_as_int` and +`_as_float` reject `bool` for the same reason `_present` does: a yes/no is not a +measurement. + +Six errors were not narrowing at all: `ctypes.windll` and `Popen._handle` exist +on Windows and are absent from the stubs mypy checks against on Linux. Those +carry targeted `type: ignore[attr-defined]` comments — one API each, with the +reason recorded — rather than a blanket suppression that would also hide the +next real defect. + +**No control changed and none was weakened**: 15/15 throughout, and the full +suite stayed green at every step, which is the only reason to believe a +mechanical rewrite of this size did not quietly alter behaviour. + +### The interval kept its meaning and gave up its secrets + +`Harness._run_once` reaped every child through `os.wait4`, which hands back the +kernel's complete per-child accounting, and then read one field of it. The other +six — user CPU, system CPU, minor faults, major faults, voluntary and +involuntary context switches — were fetched and dropped on the floor. + +That mattered because those six are exactly the fields that separate the +candidate explanations Round 7 exists to separate. A wall-clock difference with +no CPU difference and a context-switch difference is a scheduler story; the same +wall-clock difference with a matching CPU difference is a work story. Without +the accounting, both look identical and the round can only report that something +got slower. + +They are kept now, under four constraints, each of them a way the change could +have been made wrong: + +| constraint | why | +|---|---| +| `ru_utime` / `ru_stime` **rounded** to nanoseconds | everything else in the harness is ns; truncation would bias every sample the same direction, and a systematic half-tick error survives averaging in a way a symmetric one does not | +| the interval **unchanged in meaning** | `t0`, `Popen`, `wait4`, `elapsed`, exactly as before. The rusage is parsed after the clock stops | +| the two pre-existing lines between `wait4` and `elapsed` **left where they were** | moving them would tighten the interval. A tightened interval silently un-compares every future number against every recorded one, which is a worse defect than the slightly loose interval it would fix | +| off POSIX, `null` **with a reason** | there is no Windows equivalent that means the same thing. A reported `0` minor-fault count for a platform nobody asked would be the most confident possible lie, and a median over such zeros would look exactly like a flat measurement | + +The fields reach the report too, not just the private Round 7 driver. A cell +carries `accounting` (summarized per field, in `ns` for the two durations and in +`count` for the four counters), `accounting_unavailable_reason`, and +`raw_accounting` per iteration. A harness that collected the accounting and then +dropped it one layer up would be the same defect wearing a different hat. + +**`perf-child-accounting`** is the sixteenth control, and it checks the claim +that would otherwise be invisible: that the parse sits outside the clock. It +does that by making the parse expensive — `os.wait4` is wrapped so every rusage +field costs 10 ms to read — and then asking whether `elapsed_ns` grew. If the +harness read seven fields inside its own stopwatch, it would bill 70 ms of its +own bookkeeping to the process it was measuring, and the check would see it. + +Seven mutations were run against the finished control, each caught by the check +that owns it: + +| mutation | caught by | +|---|---| +| `ru_utime` returned unconverted, in seconds | `cpu_user_ns = 0` for a child burning tens of milliseconds | +| `int()` instead of `round()` in the conversion | the conversion table, at the nanosecond | +| the rusage parsed before `elapsed` | 174 µs outside the interval against 49 ms of deliberate delay | +| zeros instead of `None` on the non-POSIX path | six fields present where none was measured | +| the cell dropping `accounting` again | a cell carrying no accounting slot | +| a field name colliding with `elapsed_ns` | the row-key collision check | +| a field with no declared unit | the `ACCOUNTING_FIELDS` / `ACCOUNTING_UNITS` symmetric difference | + +The last two are worth their own line, because the first version of them did not +work. Both faults make `measure_cell` raise `KeyError` partway through a cell, so +the control appended its finding to a list and then died two steps later — CI +would have shown a traceback naming the crash site and no `FAIL` line naming the +cause. The checks are terminal now: they report and return before reaching the +code their own subject breaks. A check that cannot survive long enough to speak +is not a check, which is the same lesson as the last several, arriving from a +direction I had not been watching. + +The non-POSIX branch is exercised on Linux by forcing the RSS mechanism, which +drives the real branch of the real function. It is **not** a Windows test and +the control says so; what it proves is that the absence path states an absence. + +### The Round 7 apparatus is not the instrument, and the digest proves it + +`scripts/round7/` holds a classifier, an ELF reader, arm B's padding source and +the B1–B4 preflight. None of it is an instrument source, and the harness digest +is **unchanged at `562a7f7232da`** across the whole addition — which is the point +worth recording. A round's apparatus that quietly joined `INSTRUMENT_SOURCES` +would restale every pair and, worse, would put the reading of an experiment +inside the thing the experiment measures. + +**One classifier, and the controls are wired to it.** `classify.py` is the only +implementation of P1–P5; a second copy would be a second opinion and the reading +could then choose between them. `round7-outcome-exclusivity` evaluates it over +50,653 exact rational triples — sixths, so the ratified edges `3/2`, `3`, `2/3` +and `2` land exactly on grid points rather than near them — and reports which +rule pairs overlap and where. Exact `Fraction` arithmetic throughout: a binary +float `2/3` would decide the `(2/3)B ≤ C` edge by rounding direction rather than +by the preregistered rule. + +The census is run twice. Once against the real rules, which must overlap only at +`A = B = 0`; once against the previous draft's P1, which must be reported broken. +A control that has only ever seen correct input is a control nobody has tested. + +**Six mutations of the real classifier, each caught by the check that owns it:** + +| mutation | caught by | +|---|---| +| the old overlapping P1 restored | P1 found overlapping another rule | +| the zero guard widened to `A or B` | `A=1, B=0, C=4` refused instead of classifying P2 | +| the zero guard removed | `A=B=C=0` raising instead of routing to P5 | +| ambiguity resolved by precedence rather than raising | the classifier returning one answer where two rules fire | +| P4's edge made strict | `C = 1.5A` falling through to P5 | +| an epsilon smuggled into the zero comparison | a tiny non-zero `A` being refused | + +The second one is the one that matters: it is the guard I proposed and the owner +rejected, and the control now refuses to let it back in. + +**And the crash-before-reporting defect recurred.** Removing the zero guard makes +`A=B=C=0` fire P2, P3 and P4 at once, so the classifier raises and the control +died on a traceback — exit code non-zero, mutation scored CAUGHT, no `FAIL` line +naming anything. Identical in shape to the finding recorded one round earlier, +in a file written after it. The control catches the raise and reports it now. +Twice in two rounds suggests the habit is to check that a mutation *fails* +rather than that the *check* speaks, and reading the output rather than the exit +code is what caught it both times. + +**The preflight reads the ELF, not a rendering of it.** `elfread.py` parses +program and section headers directly. B1 locates the padding through `st_shndx`, +which names its section outright, rather than by matching its address against +section ranges — an inference that quietly finds nothing at all for a +non-allocated section, whose address is zero. That distinction is not +theoretical: it is exactly what the B2 damage case constructs. + +The four damage cases are **built**, not simulated. A real linker really does +drop an unreferenced non-`volatile` constant under `--gc-sections`; a section +emitted through inline asm with empty flags really is absent from every +`PT_LOAD`. The first attempt at that second case failed to produce the damage at +all — gcc marked the custom section `SHF_ALLOC` anyway and B2 passed it +correctly — which is why the mutation was checked before being believed. + +### The execution contract, and a defect that keeps coming back + +The Round 7 apparatus classified correctly and measured nothing, which turned +out to be three different silences. The owner's implementation review passed the +code and then asked what the design still did not say: **which bytes get timed, +in what order, doing how much work.** + +**Which bytes.** The committed preflight proves properties of specific sha256s. +Any runner that preflighted, dropped its temporary directory, rebuilt and then +measured would be proving things about one pair of arms and timing a different +pair with the same filenames. `runner.py` is therefore one transaction — bind, +build once, preflight *those* files, freeze sha256 and byte length, then time +*those same* files with identity re-verified before every block and after the +last, all outside the clock. + +**In what order.** The preregistration fixed session and half counts and said +nothing about order, which is enough to lose the whole round: all of A, then all +of B, then all of C, and an hour of machine drift becomes "the effect of the +real binary" — a result that would have survived every other check in the PR. +Blocked randomisation now: 40 blocks of `(regime, n, session)`, all three arms +inside each block with an arm's halves adjacent, arm order and block order both +deterministically shuffled, seed and planned and actual order all recorded. + +The seed is `0xf937b36bd4dac422`, the first 16 hex digits of the Round 6 +helper's sha256. Not a number I picked: a literal of my own would be equally +deterministic and strictly less auditable, since nothing but my word would stop +me re-rolling it until the printed order looked tidy. A control compares the +constant against the committed artifact. + +**How much work.** "The Round 6 helper at its 2 ms rung" was prose. It is now +read from the ladder that established it — 460280 iterations — with a stop +condition requiring arm A's sha256 to equal that file's `helper_sha256`. Arm A +as built already **is** that helper, byte for byte, so nothing needed +recalibrating. If a future build differs the round stops rather than hunting for +a new iteration count, which would be a knob turned after authorisation. + +**Nine mutations, and the third recurrence of one defect.** Eight came back with +a finding that named the cause. The ninth — hard-coding the work count instead of +binding it — exited non-zero with no `FAIL` line, because the control crashed +before reporting. That is the same shape recorded twice already. + +It was caught this time because the mutation runner itself was changed to demand +a `FAIL` line rather than a non-zero exit, having been fooled by exactly this +twice. The crash then exposed a genuine defect rather than a test artifact: +`bind_work` called `Path.relative_to(ROOT)` and raised `ValueError` on any ladder +outside the repository, which is precisely what a fixture passes it. Both were +fixed: the path now falls back to a bare name, and the control reports an +unexpected raise instead of dying on it. + +The lesson has now cost three rounds, and the durable fix was not another +resolution to be careful. It was making the tool that scores mutations unable to +accept silence as success. + +### The sample was clamped in the vice, and nobody checked it was alive + +Round 7 called `Harness._run_once` directly. That gave it the instrument's +measured interval and skipped the layer wrapped around it — the layer that +exists because twelve cells once timed `command-not-found` accurately, +reproducibly, and to no purpose. + +So the round had three arms bound byte-for-byte to the right binaries, running +in a preregistered order, doing a work count traced to a committed ladder, and +**nothing checked an exit code**. All that identity work would have measured the +wrong path with great precision. + +The fix is Round 7's, not the instrument's: `perf_baseline.py` is untouched and +the digest stays `562a7f7232da`. Before the clock, each arm proves untimed that +it does its job — A and B must exit 0 at 460280 iterations; arm C goes through +the instrument's own `core-usage` rung, `expect_rc` 2 **and** the `usage-help` +evidence, reused rather than restated. Then every spawn, warmup discards +included, must exit its arm's code, and one stray stops the round and records +arm, block, half, warmup-or-sample, index and the observed code. + +Exit 2 alone is not sufficient and a control proves it rather than saying it: a +stand-in that exits 2 and prints nothing is handed to the preflight and refused. + +**Seven mutations, and three of them found holes in my own control** — which is +the part worth recording: + +| mutation | first result | +|---|---| +| timed rc check removed | caught | +| warmups no longer checked | caught | +| every arm expected to exit 0 | **crashed the control** — no finding | +| arm C judged by exit code alone | **missed** — the control read the contract string, not the decision | +| the outcome preflight not a stop condition | **missed** — never tested | +| `usage-help` stops requiring stdout | caught | +| `usage-help` tolerates stderr | caught | + +The crash was the fourth appearance of the same ghost, and it was visible only +because the mutation runner now refuses to score a non-zero exit as CAUGHT +without a `FAIL` line. The two misses were worse in kind: checks that passed +happily while the thing they described was broken. One asserted that arm C's +contract *string* named the rung, which stays true however the verdict is +computed; the other never existed at all. + +All three are closed and all seven now come back with a finding. The general +lesson is getting expensive to keep relearning: a control is not evidence that +something works, it is a claim that needs its own adversary — and the cheapest +adversary available is a mutation runner that will not accept silence. + +### Refusing correctly is not the same as recording the refusal + +The Round 7 runner refused a bad run properly and then lost the evidence. The +breach escaped `run()`, so `main()` never reached its own `--out` write: 239 +halves measured, a stray exit on the last one, a traceback, and no file. The +instrument fell down the stairs gracefully and left no black box. + +The control was the same mistake one level up. It read `exc.strays` from the +exception object and called that "recorded with arm, block, half and index" — +in memory, where nobody at 3am can find it. It is the same family as scoring a +mutation by its exit code: read the thing, not a proxy for it — and this is the +first time the measurement runner itself played the part. + +One boundary now catches every `ExecutionContractBreach` and writes +`run_valid: false`, null `measurements`, and a structured `abort` naming either +the exact spawn (arm, block, half, warmup-or-sample, index, observed and +expected rc) or the exact arm (when, expected and observed sha256). Completed +halves survive as `partial_measurements`, flagged `not_evidence` with the reason +attached. `time_half` raises on the first stray instead of finishing the half. + +`round7-durable-refusal` never inspects an exception. It drives the runner to a +forced stray and to a real mid-run identity drift, then reads the filesystem. + +**And it crashed on its own first mutation.** Removing the try/except — the +original defect, restored — let the breach escape through `rn.main()` and kill +the control instead of being reported by it. Fifth appearance of the same shape, +this time inside the control written to detect that shape. The mutation runner's +insistence on a `FAIL` line is the only reason it was visible. `drive()` now +converts an escaping exception into a finding. + +Seven mutations, all caught with a finding: the original escape, exit 0 on an +invalid run, measurements retained, `run_valid` never falsified, the abort +reduced to prose, identity drift losing its kind, and a half that keeps spawning +after a breach is known. + +### The instrument measured something, and the answer is "not here" + +Twelve review rounds built an apparatus to make one measurement honest. The +measurement ran once, on the exact head the owner pinned it to, and the formal +outcome is **(process-cold P4, warm P5)**: the witness did not reproduce in the +cold regime, and the warm regime declines to say. + +240 halves and 2640 spawns, every exit code contracted and checked, zero +strays, zero identity drift. The accounting is worth stating exactly, because +one careless noun turns a true sentence false: **2400 retained samples**, of +which 1600 exited 0 (arms A and B) and 800 exited 2 (arm C), plus **240 warmup +discards** whose exit codes were checked on the same contract — any stray would +have invalidated the run — but whose rows are deliberately not retained, because +discarding them is what the `warm` regime means. Half-to-half drift across all three arms landed between +0.024 ms and 0.090 ms. Arm C cleared the P4 boundary in exactly one of the four +cells, `warm` at n=15, and a rule must hold at both counts to fire. + +**A provenance claim here was withdrawn, and the withdrawal is the interesting +part.** This note originally said the reading "was written before the data +existed, and that is checkable". The operator did record a pre-clock sha256 of +`scripts/round7/readout.py` — `0f14be8a491d` — but **git cannot check that**: +the file is absent from the authorised head `7ad4a0b` and enters the tree in the +single post-run commit, beside the dataset and the reading. So the word +"checkable" was doing work nothing supported. That is an assertion dressed as a +check, published in the note that exists to argue against assertions dressed as +checks, one round after the same defect was recorded as finding 4. + +What the repository does establish is the part the result rests on: **D, the +P1–P5 rules, the zero-A guard, the attribution gates and the stop rule were all +committed before any measurement existed**, and `readout.py` delegates every +classification decision to that frozen `classify.py` instead of restating it. +`round7-readout` recomputes the committed reading from the committed dataset on +every CI run, on Linux and on Windows. The outcome is determined by precommitted +rules and a reproducible application of them; the authoring order of one file is +not load-bearing, and should never have been offered as though it were. + +It earned its keep immediately. The synthetic cases caught the author's own +boundary arithmetic *again* — `(A, B, C) = (1, 3, 4)` was asserted to be P3 and +is a clean P1, because `C >= 2B` needs `C >= 6` — the third time in this PR a +hand-checked edge was wrong and a control found it. Then nine mutations found +two more holes: a refusal case that appeared to test the `run_valid` gate but +was actually refused one line earlier by the missing-measurements check, proving +nothing about the gate it named; and a reading that died with a `KeyError` +instead of refusing when a repetition count went missing. Sixth appearance of +crash-instead-of-finding. `read()` now refuses by name, and the control reports +an escaping exception rather than being killed by it. + +**Both corrections were owner-found, and the second one bit twice.** Adding a +control for the spawn accounting — so 2400 and 2640 are computed from the +dataset rather than quoted — produced two fresh instances of the same defect in +a row. The first compared `rn.WARMUP_DISCARDS` against a spawn count derived +from `rn.WARMUP_DISCARDS`, so mutating that constant moved both sides together +and the check stayed green: a check reading a proxy for the thing it checks. +The second was worse. The repaired block landed inside an `except` branch, so it +ran only when the dataset failed to read — dead code on every healthy run, while +the control's success line went on announcing that it had verified 2400 retained +samples. An assertion that sounds like a check, written into the edit whose +entire purpose was to remove one, in the file that exists to catch exactly this. +Both were found by mutation, not by reading. The accounting now pins to the +ratified literals and to the dataset's own recorded spawn count, runs before the +reproduction check, and three constant-drift mutations come back with findings. + +**The mechanism table was not applied.** P4 fires no elevation and P5 fires no +rule, so neither regime licenses an attribution; the reading records the refusal +and its reason in both. The temptation to look anyway — the numbers are right +there, and `warm` n=15 has a C/A of 3.7 — is precisely what the preregistration +exists to overrule. A P5 that gets analysed until it says something is not a P5. + +Nothing moved as a result. No threshold, no budget, no floor, no envelope, +`0.35` not consulted, no session dropped, no re-run. The preregistered stop rule +for P4 or P5 in a regime is "stop after reporting; neither licenses a policy +change", and both regimes hit it. + +### The gate was never a missing file + +The owner accepted Round 7 and then declined to accept #263-A, for a reason +worth recording carefully: the blockage is **not** an absent artifact named +`calibration-of-record`. §13 of the frozen brief asks for an instrument, a +`CALIBRATION_ONLY` validation report and a fresh exact-head PASS, and all three +exist. But §7 requires a mechanical noise and outlier policy fixed in advance +plus a determinism check, and §9 says a second run on the same environment must +reproduce within that policy or the instrument is **not yet frozen**. + +This repository's own evidence says it does not: the sizing pairs do not +reproduce reliably, and `n=5` has passed and failed here in no pattern. Reading +§13 and treating §9 as decorative would have been a very human way through the +gate — produce the JSON with the right name and declare victory — and it is +precisely the move twelve rounds were spent dismantling. We do not need a file. +We need an instrument that says compatible things twice. + +`docs/notes/p022-263a-calibration-policy-proposal.md` is the authorised +no-clock answer, and it contains **no numbers on purpose**. Six constants are +named, given units, and left empty, in a table that exists so a later invented +value is visible. + +Three things in it are load-bearing. + +**The incumbent comparison is not symmetric.** `reproduce()` computes +`|m_B − m_A| / m_A`, dividing by whichever run was recorded first. For tolerance +`T` and ratio `r = m_B / m_A` the forward direction refuses above `1 + T` and the +reversed direction above `1 / (1 − T)`, so for **every** positive `T` there is a +band `1 + T < r < 1/(1 − T)` where the verdict depends on run order and nothing +else. That is algebra about the form, not a number, and it was verified +exhaustively rather than asserted. No committed verdict is known to sit in that +band, and the proposal deliberately does **not** go looking: searching recorded +pairs for one that flips is selection on outcome wearing a lab coat. The +replacement compares `|Δ|` against a bound evaluated at the **midpoint** of the +two medians, which removes the asymmetry by construction. + +**The constants must be fitted to dispersion, never to pass/fail labels.** This +is the whole firewall. "Which historical pairs should have passed" is a label +applied after the outcomes were seen; a tolerance fitted to those labels is +tolerance shopping completed in one step, guaranteed to ratify the history it +came from and to predict nothing. A bound fitted to the instrument's own +observed variation as a function of duration is a claim a fresh pair can +falsify. + +**N is chosen before the validation pair, not by escalating until it passes.** +"The smallest N at which the pair reproduces" is the same shopping move with +better manners: it turns the stop rule into a starting gun. N is predicted once +from the fitted dispersion model, committed, and tested exactly once. + +And the rule that makes the rest mean anything: **on a failed holdout the +constants are not adjusted.** Not widened, not refitted, not re-estimated with +the new data folded in. The policy goes back to the owner as failed. + +### A reasonable statistical plan is not a computable function + +The owner ruled the policy proposal CHANGES REQUIRED with four P0 findings, and +the sentence that explains all four is theirs: the gap between a reasonable +statistical plan and a single computable function is where people hide knobs. + +The verdict universe contradicted itself — three verdicts declared, a fourth +used — and the holdout branch depended on the missing one. The fitting corpus +mixed instruments, allowing constants to be calibrated from stale halves and +museum pieces recorded under superseded harness identities. The fit said "a +quantile at level `q`" without saying how intercept and slope come out of data, +and claimed `q` was fixed by the procedure that consumes it, which is circular. +And `N` selection required predicting dispersion at a given `N` using a model +with no `N` in it, which works beautifully until someone asks where the +prediction came from. + +Two things learned while fixing them. + +**The tie-break is load-bearing.** Specifying the fit as a non-negative linear +quantile regression solved by exact vertex enumeration is only single-valued if +ties are resolved by a stated rule, because a quantile regression optimum need +not be unique — a whole face of the polyhedron can attain it. Over three hundred +random datasets the optimum was non-unique in thirty-four, and the tied solutions +disagreed in the intercept by a wide margin. Without a tie-break, two correct +implementations return materially different constants and both are entitled to +say they followed the document. The rule is now stated, with a principle it can +be checked against: **a tie is never resolved in the direction that makes the +gate easier to pass.** The vertex-enumeration claim itself was verified against +grid search before being written down, rather than asserted. + +**There is no admissible fitting corpus today, and saying so is the finding.** +Applying the firewall honestly to what this repository holds leaves everything as +*form* evidence and nothing as numeric training data under the current harness +identity. Round 7 measured a process-shape A/B/C experiment, not a repeated +calibration population; the same stopwatch does not make it the same statistical +population. So the path forward gains two separately authorised measurements — +one training collection, one holdout — instead of constants squeezed out of the +museum exhibit. + +The other repair worth naming: `N` is now a **stratum**, not a parameter. Giving +the model a closed-form `N` dependence would import the assumption that the +dominant variability is sampling uncertainty of the median, which is exactly what +Round 6 declined to establish and named as its own alternative. A functional form +nobody has evidence for is not a repair, it is missing knowledge in mathematical +notation. + +### The tie-break was fine; the sentence defending it was not + +Revision 2 of the policy earned PASS WITH MECHANICAL CORRECTIONS: two P0 and two +P1, none of which changed the statistical model. Two are worth recording. + +**Exact arithmetic said nothing about how a constant is written down.** The +document refused a floating-point LP solver on exactness grounds and then left +its constants as "a dimensionless number", so a committed decimal would be read +as a binary float by one implementation and as a rational by another, and the two +would disagree on every boundary case. Constants are now canonical integer pairs +— reduced, positive denominator — and reading one through a float is a refusal. + +**A rule was good and its justification was false.** The lexicographic tie-break +(smallest `A_abs`, then smallest `R_rel`) was defended with "a tie is never +resolved in the direction that makes the gate easier to pass". The owner pointed +out that tied optimal lines can cross. They can: observations +`(8, 20), (8, 10), (3, 11)` at `q = 1/2` have two minimisers at equal loss, +`A_abs = 28/5, R_rel = 9/5` and `A_abs = 11, R_rel = 0`, and the rule picks the +first, which is **looser** for every `t > 3`. Found by search, not by argument, +after a first randomised sweep found nothing because its generator kept driving +ties onto the `R_rel = 0` boundary where the claim happens to hold — a reminder +that a search finding nothing is evidence about the search. + +The rule survives unchanged as pure canonicalisation, which is all it was ever +needed for. Only the promise was removed. That is the sharpest form of this PR's +recurring lesson to date: not a broken check, but a working mechanism with a +sentence attached that quietly claimed more than the mechanism delivers — and +prose is where that is cheapest to write and hardest to test. + +Also closed: the implementation now precedes the training data in the sequence, +because code written with the data already on disk can be nudged in a hundred +defensible small ways, and **code that decides admissibility must not have weaker +provenance than code that starts the stopwatch**. And `N_max` is gone; a finite +frozen ladder already ends somewhere, and a second maximum expresses nothing but +a future argument about which one wins. + +### Zero is greater than or equal to twice zero + +The owner reviewed a head eight commits behind and reported three execution +blockers that were already closed, plus one defect that was entirely real and +still in current code. The stale items were stale; the live one was live. Both +halves of that sentence matter, and the second is why a review of an old head is +still worth reading line by line rather than dismissing by SHA. + +Every mechanism-attribution rule is a ratio against a quantity that can itself be +zero, and `0 >= 2 * 0` is true. A cell where **nothing moved** — zero wall drift, +zero CPU delta, zero context switches, zero faults — fired **all three** +mechanisms: a confident attribution of a drift that does not exist. Found by +reading the rule, not by running it. + +Two guards are the owner's, ratified: the context-switch and fault predicates now +require a strictly positive median before the ratio is consulted. The third is +mine and flagged as an addition they may strike: attribution applies only when +the arm's wall-clock delta is positive, because `work` degenerates the same way +and their two guards do not reach it. + +**The control then missed three of the five mutations.** Its only degenerate case +had zero wall drift, so the new precondition returned before either ratified +guard was reached; removing them changed nothing and the suite stayed green. The +case that actually exercises them is the interesting one anyway — **wall time +moved and not one kernel counter did** — which the preregistration already names +as a reportable result, and which the unguarded rules reported as scheduler *and* +faults, the exact opposite of the truth. A sixth mutation then showed arm A's +reference was never consulted either, because the live-signal case left arm A at +zero, so `>= 2 * a_faults` held however the rule was written. Eight mutations now +come back with findings. + +The hole never fired in the recorded round: `process-cold` was P4 and `warm` P5, +neither licenses an attribution, and the committed reading is byte-identical +before and after. It was latent, and a latent wrong answer is still a wrong +answer waiting for the first dataset that asks. + +### Step 2: a policy that cannot hold a number + +The owner ratified the calibration mechanism and the `median |Δ elapsed| > 0` +precondition I had flagged as mine to strike, on the grounds that `work` has the +same structural zero-hole and the value is structural rather than empirical: if +the quantity being explained is zero, attribution has no subject. + +Two mechanical corrections landed first. "No constant defaults" had named only +the constants that appear in a formula, leaving `R_runs` and the `N` ladder free +to be hard-coded without contradicting a word of it — and those two decide corpus +cardinality and `N` selection outright. All five now travel in one immutable +`DesignConstants`, required, no default. And representation is split by kind: +rationals as reduced pairs, counts as integers, so nobody has to work out whether +`N = 15` is the integer or the pair `(15, 1)`. + +`scripts/calibration/policy.py` is step 2 of the ratified twelve-step sequence, +written before any training corpus exists. It holds **no values**: nine controls +check that mechanically, including one that walks every callable the module +defines and refuses any default that is not absent or `None`. + +Seventeen mutations, and the last four were the instructive ones. + +**Two assertions were too weak rather than the code being right.** A mutation +flipping the tie-break came back green because the fitting corpus had a unique +optimum, so the rule was never exercised. A mutation deleting the fitter's +boundary candidates came back green because the control asserted only that the +result was non-negative — and the collapsed answer, the corner `(0, 0)`, is +non-negative and wrong. Both are now decided by a corpus that forces the issue: a +falling corpus whose every pair-line has negative slope, so the optimum can only +sit on a boundary, and a corpus with two genuine minimisers. + +**And one rule could not be exercised at all.** The tie-break's second key only +matters when two minimisers share an intercept, which no natural corpus here +produces. Rather than leave it unverified or invent a corpus to force it, the +rule is now a named function and is tested as a rule. A canonicalisation that +nothing checks is a convention, not a guarantee. + +The first version of the no-defaults control also reported ten findings about +`dataclass(frozen=False)`, because it walked everything in the module's namespace +rather than what the module defines. A control measuring the wrong thing is +cheaper to write than one measuring the right thing, which is why it keeps +happening. + +### The exact domain had one door, and the building had no walls + +The owner declined to freeze the step 2 implementation, and was right to: the +exact-arithmetic boundary was enforced at `DesignConstants.from_committed()` and +nowhere else. `Envelope`, `Observation` and `CellObservation` took whatever they +were handed. + +Driven rather than argued, that is worse than it reads. `Fraction * float` is a +**float** in Python, so a float entering through a dataclass constructor made the +**fitted `R_rel`** a float, and with it the bound and the comparison that decides +the verdict. The module had refused a floating-point LP solver on exactness +grounds while floats walked in the front door. + +Every quantitative entry point now refuses non-exact input, and refuses rather +than converts: `Fraction(0.1)` preserves the binary error with impeccable +fidelity, which removes nothing. An `int` is refused too — exact in itself, but +`int / int` is a float in Python, so admitting it leaves a float one ordinary +division away. `calib-exact-domain` checks both halves: eleven non-exact inputs +refused at the door, and nine computed quantities that must all come back +`Fraction`, because refusals guarding a building with no walls prove nothing. + +Ten mutations, nine caught. **The tenth is recorded as uncovered rather than +counted as covered.** Removing the float guard inside `observations_from_medians` +changes the message and not the outcome, because `Observation` refuses the same +floats a line later. That guard is defence in depth and no mutation can +distinguish it, which is now said in both the code and the control instead of +being left to read as tested coverage. + +The document also contradicted itself about its own authority — a header saying +"PROPOSAL. Nothing here is ratified" above a body correctly reporting the +mechanism as ratified. An artifact a freeze will point at cannot be ambiguous +about what it is. It now opens with an explicit status block and is revision 5. + +### Four forgotten calls, and the check that should have existed first + +The exact-domain repair closed the constructors and left the arithmetic open. +`Envelope.inner(0.1)` returned a float. `pinball_loss` took `q`, `A_abs` and +`R_rel` straight from a caller and validated none of them, so the objective that +decides the fit could be computed in binary floating point. `canonical_minimiser` +would happily return a float pair. `as_pair` died with `AttributeError` rather +than refusing. + +All four are now guarded and all six mutations of them come back with findings. +The serialiser cannot corrupt a fit, but a surface that fails closed everywhere +except one function is a surface somebody will later argue about. + +**The durable fix is not four more refusal cases.** The root cause was four +*forgotten* calls, so `calib-exact-domain` now enumerates every public callable +the module defines and requires each to be accounted for — either guarded and +exercised by a refusal case, or explicitly recorded as taking only validated +policy objects. Adding a new public function without that accounting fails the +control; adding a stale name to the list fails it too. Verified by adding a +throwaway unguarded function and watching it get named. + +The lesson is the PR's oldest one wearing yet another hat. "Every quantitative +entry point refuses non-exact input" was a sentence about the code, published +while four entry points did no such thing. The sentence is now a check that +enumerates the surface rather than a claim about it. + +### Both pairs are stale, and are not re-recorded + +The digest moved from `2d6e52fe4352` to `6713e7300c7c`, and again to +`562a7f7232da` under the accounting change described above, so all four committed +halves describe an instrument that no longer exists. They are **left in +place**: re-recording is a measurement, and new measurements are not currently +authorised. The evidence is stale and says so rather than being quietly +refreshed. + +### The manifest digest was hashing raw bytes + +Round 3 content-addressed the harness digest and left `load_manifest()` hashing +raw bytes two hundred lines away — the same defect with a different variable +name, on a value C1 also freezes. `.gitattributes` pins the manifest to LF, but +an attribute only governs files git checks out under it; a zip download or a +clone predating the rule still differs. Normalization now lives in one function, +`normalized_text`, that every identity uses. The value is unchanged on Linux, so +this closes a Windows exposure without moving any number. + +### The harness digest names content, not a checkout + +D7's C1 will freeze the harness digest, and #263-B runs on **both** platforms, +so that value has to be the same on both. It was not. The same tree hashed +`af32f04ddbad` on Linux and `51ef2ca2422a` on a Windows runner, where +`core.autocrlf` rewrote the instrument source on checkout — one instrument with +two identities, and a frozen C1 that would arm on one platform and refuse on the +other. + +This repository already knew the defect class: `.gitattributes` pins +`docs/evidence/*.json` to LF because the mutation campaigns' definition hashes +hit it first, which is exactly why the *workload manifest* digest matched across +platforms while the *harness* digest did not. But an attribute only governs +files git checks out under it — a working tree that predates the rule, a zip +download, or a contributor with a different config all still differ. So the +digest normalizes line endings itself rather than delegating its identity to a +checkout setting. `sha256_file` stays raw: the candidate binary's identity is +its actual bytes, and normalizing a binary would be a different kind of wrong. + +`perf-digest-platform-stable` holds both halves. + +### Reproducibility answers three questions, not one + +A re-run can disagree with the first run in ways that mean completely different +things, and one verdict cannot carry them. + +* **`outcomes_reproduced`** — both runs did the same work: the same cells exist + and every outcome is identical. A disagreement is a defect in **this harness** + and always fails. +* **`timings_reproduced`** — the medians agree within the policy. A + disagreement says the numbers did not settle. It does **not** say why: a + contended runner, a genuinely variable workload, and a median estimate that is + simply uncertain at this repetition count are indistinguishable from here. + Calling it "the environment" would assert one of three causes without + evidence, which is exactly what an earlier draft of this section did. +* **`environment_valid`** — the noise probe's own verdict. + +`reproducibility.reproduced` keeps the meaning it has always had: everything +agreed. It is the conjunction, **not** a renamed subset. A red result must never +disappear because a word changed profession. + +All three are required for a report of **record**. A CI leg exists to prove the +instrument stands up, so it may pass while recording `timings_reproduced: false` +as a diagnostic — but the committed calibration may not, and +`perf-provenance-complete` checks all three on the shipped artifact. + +### Three policy constants, one historical value + +One constant played three roles, and the report claimed the reproducibility +tolerance was "the noise floor recorded by the earlier run, not a chosen +number". That was false twice over: the recorded limit *is* that constant, so +reading it back was reading the constant through a JSON detour, and nothing +about it tightened on a quiet machine. + +| policy | bounds | +|---|---| +| `NOISE_PROBE_MAX_RELATIVE_IQR` | dispersion **within** one probe | +| `NOISE_PROBE_MAX_DRIFT` | opening probe **against** closing probe | +| `REPRODUCIBILITY_MAX_MEDIAN_CHANGE` | one cell's median, run A **against** run B | + +These are three different statistical quantities. They are separated so each can +be argued about on its own terms. **The value is 0.35 for all three and is +deliberately unchanged**: it is *chosen*, and what makes it admissible is that +it was chosen before the runs it judges and is not adjusted after seeing which +of them it rejects. + +### Calibration sizing: one pre-registered experiment + +At 5 calibration repetitions a run failed `timings_reproduced` on exactly one +cell of forty — `core-full-human|rust|cal-facts-medium|warm`, median 7.57 ms, +IQR 3.06 ms, so its own observed relative spread was **0.404** against a 0.35 +tolerance, and it was the only cell in the run whose spread exceeded it. + +The obvious reading — "too few samples" — is a **hypothesis, not a proof**. More +samples reduce the uncertainty of the *median estimate*; they do not reduce the +*intrinsic* spread of the workload's distribution. If that distribution really +is ~40% wide, it stays ~40% wide at any repetition count. + +So the escalation was bounded **in advance**: + +1. `n=15` is the only permitted sizing escalation from the observed `n=5`. +2. `REPRODUCIBILITY_MAX_MEDIAN_CHANGE` does not move. +3. The `n=5` evidence is preserved as exploratory, non-admissible — with the + caveat in the paragraph below: the *original failing artifact was destroyed*, + and what is preserved is a fresh pair. +4. If `n=15` also fails `timings_reproduced`, **stop** — no 25, no 45, no + turning the knob until CI is green. + +`n=15` reproduced on all three axes, and the largest observed relative IQR fell +from 0.404 to 0.128. That is *consistent with* the n=5 spread having been an +unstable estimate rather than the distribution truly being that wide — and it is +equally consistent with a quieter machine. One paired trial cannot separate +them, and this note does not claim it did. + +**`n=5` is intermittent.** Across four observed `n=5` pairs it has now failed +twice and passed twice. So the original failure was neither a one-off nor a +systematic insufficiency: on this machine an `n=5` pair reproduces about half +the time. Both halves of the final failing pair are committed in +`docs/evidence/p022-263a-sizing-n5*.linux.json`, deliberately named so they do +*not* match the glob that identifies a report of record. + +### A pair is one experiment, or it is two + +Run A and run B once diverged on `tree_sha` **and** `python_reference_commit`, +because A was *committed* before B was measured and `python_reference_commit()` +is `git rev-parse HEAD`. Committing evidence between the halves moved the +recorded reference identity while `ownlang` had not changed at all — a direct +breach of the single-reference rule (§12) produced by the procedure rather than +by the code. + +The pair-integrity check did not catch it: it compared harness digest, +repetitions and warmup, and said nothing about the reference or the **candidate +binary**. Those pairs happened to use one candidate, but nothing required it, so +a future pair could have compared two different binaries and reported +`reproduced: true`. + +**The procedure.** Both halves are measured on ONE clean source commit, written +*outside* the repository, verified, and only then copied in and committed +together. There is no need for A to be committed before B is measured; A must be +committed by the time the evidence ships, which is a different moment. + +``` +clean source commit S + run A -> scratch/.json (tree S, dirty false) + run B --reproduce scratch/.json + -> scratch/.json (tree S, dirty false) + verify identity on every axis below + copy A and B into the repository + one evidence commit +``` + +The scratch files must carry **their final committed names**: `earlier_run.path` +records the basename it was handed, so a scratch name would leave run B pointing +at a file that never ships. + +**`PAIR_IDENTITY_FIELDS`** — the 10 axes two halves +must share: `tree_sha`, `tree_dirty`, `python_reference_commit`, `python_reference_tree`, `workload_manifest_sha256`, `harness_digest`, `calibration_repetitions`, `warmup_discards`, `candidate_sha256`, `candidate_bytes`. + +An earlier revision of this paragraph listed nine and omitted +`python_reference_tree`, which the code had carried since the reference identity +was separated from HEAD. A prose inventory of a tuple is a second copy of that +tuple, and the second copy is the one that goes stale. + +`reproduce()` **refuses** to produce a verdict when any of them differ, so a +mismatched pair is not merely detectable afterwards — it cannot be made. The +control is the second lock, checking the same axes on evidence that already +exists. + +### What the corrected pairs actually showed + +Re-recording under the fixed procedure was required for provenance, not to +obtain a different answer. It produced a different answer anyway, twice, and +neither is being treated as a result to bank. + +| pair | outcome | +|---|---| +| first corrected attempt, `n=5` and `n=15` | both **passed** | +| second corrected attempt (final filenames), `n=5` | **passed** | +| second corrected attempt, `n=15` | **failed** — one cell, `core-full-sarif\|rust\|cal-facts-medium\|process-cold`, 0.361 | +| third, under the D7 §6 / reference-identity repair, `n=5` and `n=15` | both **passed** | +| fourth, under the anchor / protocol repair, `n=5` and `n=15` | both **passed** | +| fifth, under the N/A / completeness repair, `n=5` | **failed** — one cell, `core-full-sarif\|rust\|cal-facts-tiny\|process-cold`, 0.508 | +| fifth, `n=15` | **passed** | +| sixth, under the D7-vocabulary repair, `n=5` and `n=15` | both **passed** | + +Running tally on this machine: `n=5` has failed three times and passed seven +times; `n=15` has failed twice and passed six times. Neither count reproduces +reliably, and which one "works" depends on when it was run. Every re-record was +forced by a provenance repair, never sought for a better answer, and the ledger +is kept in both directions for exactly that reason. + +**So no calibration of record is restored.** Re-running was authorised to repair +provenance; promoting whichever pair happened to pass would be selection +regardless of why the re-run happened, and by now the coin has been watched land +enough times to know it is a coin. Both pairs ship as **sizing evidence**, pass +and fail alike, and `p022-263a-calibration.linux.json` stays absent until the +variance characterisation says what the measurement model should be. + +The previous revision of this paragraph warned that four consecutive passes were +exactly where selection starts to look like evidence, and cautioned against +reading them as a result. The very next attempt failed. That is not a vindication +of the caution so much as a demonstration of what it was about: the streak was +never evidence of anything, and neither is its ending. Across the whole history, +**five distinct cells** have fallen outside tolerance at least once — every one +of them a `rust` cell with a median under 10 ms — while `n=5` stands at three +failures against seven passes and `n=15` at two against six. The run that fails +is not the run that is wrong. + +Six attempts in, the sequence reads pass, pass, fail, pass, fail, pass for `n=5`. +Nothing about that is a trend, and the ledger exists so that no revision of this +note can quietly become one. + +The failures stay in the ledger and in `docs/evidence/historical/` rather than +being summarised away, and the failing `n=5` pair from this round ships exactly +as recorded. Re-running it to obtain a passing partner would be the precise move +this instrument exists to make impossible to hide. + +### Pre-contract artifacts, kept and quarantined + +The four artifacts committed before the pair-identity contract existed fail it +by construction: their `earlier_run` blocks predate the fields it requires, and +their halves genuinely were measured under two different reference commits. + +They are preserved **byte-identical** under `docs/evidence/historical/`, outside +the glob the live controls scan. Not deleted, because they are the record of a +real measurement and of the defect that produced it; not left in place, because +a control that must exempt specific filenames is a control with a list of +excuses. The alternative — an explicit exemption inside the check — was offered +to the owner and this location was chosen pending any objection; the move is +byte-preserving and trivially reversible. + +### The escalation was spent, and it did not work + +`n=15` failed too — and failed **worse**. + +| pair | cells outside `REPRODUCIBILITY_MAX_MEDIAN_CHANGE` | worst | +|---|---|---| +| `n=5` | 1 of 40 | `core-full-sarif\|rust\|cal-facts-medium\|process-cold`, 0.478 | +| `n=15` | 3 of 40 | `core-usage\|rust\|cal-facts-tiny\|process-cold`, 0.516 | + +Both pairs reproduced their **outcomes** exactly and both environments were +valid. Only the timings disagreed. Tripling the repetition count did not reduce +the disagreement; it produced more of it. + +This outcome is consistent with the pre-run alternative that increasing N need +not restore reproducibility when the dominant variability is not sampling +uncertainty of the median. It falsifies the narrower operational hypothesis +tested by the preregistered escalation: that moving from `n=5` to `n=15` would +reliably produce an admissible calibration on this setup. It does **not** +establish the cause of the remaining variability, nor distinguish intrinsic +workload spread from between-run environmental variation. + +The earlier claim that this was "the predicted result, predicted before the run" +said more than the evidence carries: nothing predicted that `n=15` would fail on +three cells or fail worse than `n=5`. What was stated in advance was only the +alternative above and the stop rule. + +**So the instrument currently has no admissible calibration of record**, and one +is not manufactured by continuing to turn the knob. The escalation permitted was +exactly one step, `5 → 15`, with a mandatory stop on failure. It failed. There +is no `n=25`, no `n=45`, and `0.35` does not move — a tolerance adjusted after +seeing which runs it rejects is a threshold fitted to a result, which is the one +thing this instrument exists to prevent. + +What is committed instead is all four halves of both failed pairs, as +exploratory evidence, on clean trees, each run B naming its run A by path and +sha256 so the verdicts can be recomputed rather than trusted. The report of +record is **withdrawn**, not replaced: `p022-263a-calibration.linux.json` is +deleted rather than left certifying a superseded instrument. + +**An observation, offered as a finding and not acted on.** Every cell that +failed in either pair is a `rust` cell with a median between 2.5 ms and 9.2 ms. +The Python cells, whose medians run 76–111 ms, held. A single *relative* +tolerance is applied uniformly across cells spanning roughly fifty-fold in +absolute duration, and it bites first where the durations are smallest. Whether +the policy should be magnitude-aware is a **measurement-design decision for the +owner**, taken with these numbers visible — which is precisely why this +paragraph proposes nothing. + +**Why 15, stated correctly.** Not "because a report of record should carry the +better-estimated median" — that argument does not pick 15. It picks 25, then +100, and then whichever number the budget runs out at. `n=15` is used because +the owner's review, **given before any result was seen**, permitted exactly one +bounded escalation from the observed `n=5` to `n=15`, with every policy constant +unchanged and a mandatory stop if it failed. That `n=15` then came back green is +a **result**, not the reason it was chosen. The distinction is the whole +difference between a preregistered step and a knob turned until CI agreed. + +CI keeps `n=5`. Its question is whether the instrument stands up, it may record +`timings_reproduced: false` as a diagnostic, and tripling every leg's runtime to +chase an artifact property it does not produce would buy nothing. + +**A record that was destroyed — stated without a euphemism.** The original +failing `n=5` artifact is **lost**. It was discarded from the working tree +before the preservation rule existed, because a control forbids committing a +non-reproducing calibration and the reflex was to revert. What is committed is a +**fresh** `n=5` pair taken under the shipped instrument; it is *not* the run +that prompted the design change. The original observations survive only as +narrative — in this note and in the PR's history — and narrative is not +evidence. A hole in provenance is not a portal to the past, and this document +will not describe it as one. + +## 14. Known limitations, recorded rather than routed around + +1. **`bridge-lowering` and `analysis` are not separately observable** (§2). +2. **Allocation counts are not captured**; only peak RSS (§9). +3. **Population B's measurements are not implemented here** (§1) — owed on their + own track, not narrowed away. +4. **`machine/cache-cold` is not claimed** (§6) — no reset protocol exists in + the CI environments this instrument runs in. +5. **Git object identity is not a signature, and signed ratification is not + offered.** The gate raises arming from "write a local file" to "land two + reviewed, committed objects" — auditable and owner-controlled — but anyone + with repository write access could author both. It therefore requires + `"signature": "none"` and **records the freeze as unsigned**. A signed mode + was written and withdrawn: it read `git verify-commit --raw` from stdout when + git writes that status to **stderr**, so a correctly signed commit would have + verified cryptographically and then been refused for not naming its own key. + No control caught it, because no environment this runs in holds a signing + key. An advertised path that is observably wrong is worse than an absent one, + so it is absent until there is a key and a control exercising **acceptance**. +6. **Launcher-scoped extraction isolation is unavailable** (§2) — recorded + rather than imputed, after the `--emit-facts` interval turned out to contain + the whole pipeline. +7. **A GitHub-hosted Windows runner is not reliably measurement-grade**, and + the instrument established that on its first day — with a sharper result + than "the runners are noisy". + + On **one commit**, two Windows runs minutes apart disagreed about their own + environment. The first refused it: relative IQR **1.807** against the 0.35 + floor, with **0.870** drift between the opening and closing probes. The + second accepted it and completed a full calibration that reproduced + within 0.35. Same commit, same runner class, opposite validity verdicts. + + So the risk is not that a Windows measurement there would be noisy — it is + that whether it is *admissible at all* turns on scheduling luck. A decisive + session that started on the lucky run and continued into the unlucky one + would be half a measurement. The harness stood up in both cases, produced a + complete and correctly-provenanced report in both cases, and reported the + environment honestly in both cases. + + This is a result, not a defect, and it is one #263-B needs before it starts: + **the decisive Windows measurement needs a single-tenant machine**, and D7 + should not preregister a Windows protocol that assumes a hosted runner. The + floor was deliberately *not* raised to make the run pass — an + instrument-validity constant chosen after seeing which runs it rejects is a + threshold fitted to a result, which is the entire failure mode this brief + exists to prevent. + + CI therefore asks the two questions separately: *did the harness stand up + and report honestly* (a gate, on both platforms) and *is this environment + measurement-grade* (recorded per run, and allowed to be "no"). diff --git a/docs/notes/p022-263a-round6-preregistration.md b/docs/notes/p022-263a-round6-preregistration.md new file mode 100644 index 00000000..ae73c0be --- /dev/null +++ b/docs/notes/p022-263a-round6-preregistration.md @@ -0,0 +1,318 @@ +# Round 6 — variance characterisation: preregistration + +**Status:** written and committed BEFORE any Round 6 measurement exists. +**Authorised at:** exact head `0374793c9aa0b9ad9b0e55013d125338ae8b0d42`, whose +CI completed success on both the push and pull_request runs, head unchanged. +**Tag:** `CALIBRATION_ONLY`. This round produces no decisive number, no +threshold, no budget, and no D7 freeze. + +This document exists so that the analysis is fixed before the data. Everything +below — what is measured, how, how many times, and which conclusion each +possible shape licenses — is decided now. A characterisation whose analysis is +chosen after seeing the numbers is a threshold hunt with better manners. + +## The question + +Six sizing attempts have produced three `n=5` failures and two `n=15` failures. +Every cell that has ever fallen outside the 0.35 policy is a `rust` cell with a +median under 10 ms, out of a population spanning roughly 1.8 ms to 3.2 s. Three +explanations remain indistinguishable from the evidence to date: + +1. **A measurement-scale effect.** Below some duration, run-to-run variation is + dominated by fixed costs — process spawn, scheduling, page faults — so a + *relative* tolerance necessarily bites hardest at the short end, whatever is + being measured. +2. **Something specific to the Rust invocations**, which happen to be the short + cells. +3. **Between-session environmental variation**, which would move everything and + merely shows first where the relative denominator is smallest. + +Round 6 separates (1) from (2) and (3) by measuring something that is neither +Rust nor Python product code, across durations that span the region of interest. + +## What is measured + +A **synthetic deterministic helper**, run in a **fresh process** per iteration, +at eight target durations: + + 1, 2, 4, 8, 16, 32, 64, 128 ms + +The helper is not Rust and not Python product code, does no I/O, and computes a +fixed, deterministic amount of work. Its per-scale iteration count is fixed by a +**one-off setup pass** whose numbers are recorded in this document before the +measurement pass runs, and is then never re-derived. A helper that re-calibrates +itself each run is measuring a moving target. + +Fixed in advance, per scale: + +| | | +|---|---| +| repetitions | `n` in {5, 15} — the same two counts the instrument permits, and no others | +| warmup | 2, the instrument's policy default, unchanged | +| independent A/B sessions | **5** per (scale, n); one session is a run A and a run B | + +That is 8 scales x 2 counts x 5 sessions x 2 halves = 160 measurement runs. + +## What is recorded, per cell + +- absolute median shift `|median_B - median_A|` +- relative median shift `|median_B - median_A| / median_A` +- MAD and IQR of each half +- **every raw observation**, not just the summary +- scheduler metadata; on Linux, CPU affinity and a context-switch signal + +**No pass/fail tolerance is computed, applied, or reported.** There is no +verdict in this round. `0.35` is not consulted, and nothing in this round may +move it. + +## Predeclared outcomes, and what each licenses + +| shape | reading | what it licenses | +|---|---|---| +| **O1** absolute drift roughly constant across the ladder while relative shift grows as duration falls | the instability is a measurement-scale effect, present in code that has nothing to do with either engine | a v2 envelope of the form `|delta| <= A + R*t` **may be designed**, with `A` and `R` estimated from **this metrology dataset only** | +| **O2** the ladder is stable at 2–8 ms while real Rust invocations keep wandering | the instability is *not* a duration-scale artifact | an absolute floor **must NOT** be introduced; the cause is elsewhere and Round 6 has not found it | +| **O3** neither shape appears cleanly | inconclusive | report it as inconclusive and stop | + +Naming O3 in advance matters: without it, an ambiguous dataset gets read as +whichever of O1 or O2 the reader was hoping for. + +## Explicitly forbidden in this round + +- Deriving `A` or `R` — or any other constant — from the Owen cells. The + metrology dataset is the only permitted source, and only under O1. +- Using `0.508`, or any other observed failing value, as or toward a threshold. + The owner's ruling stands: a v2 envelope and a fitted acceptance bound are two + different statistical professions, however much the numbers enjoy dressing up + as each other. +- Introducing an absolute noise floor under O2. +- Choosing `T_min`, `N_min` or `N_max`. +- Moving `0.35`, `--warmup`, or trying any repetition count other than 5 and 15. +- Any decisive workload, any decisive timing, any resource exposure of decisive + work, any D7 threshold or budget, any C1/C2 freeze, any #263-B, any Stage 3. + +## What may be used as input + +The existing calibration history may be read as calibration evidence. This is +not forbidden peeking: frozen #263-A permits calibration variance as an input to +sizing the instrument, and the owner has ratified that reading. In particular +the observation that all five historical failures sit on `rust` cells under +10 ms may be investigated. What may not happen is that observation becoming a +number in a D7 acceptance rule. + +## Stop rules + +- If the setup pass cannot produce stable per-scale iteration counts, stop and + report; do not proceed with a helper whose duration is not fixed. +- If the measurement pass cannot complete a full session for any (scale, n), + report the gap rather than substituting a partial session. +- On O2 or O3, stop after reporting. Neither licenses a change to any policy. + +## Deliverables + +- The setup pass's per-scale iteration counts, recorded in this document. +- A committed metrology dataset with every raw observation. +- A written reading against O1/O2/O3, decided by the table above rather than by + what would be convenient. + +## Amendment 1 — the helper is compiled, recorded before any measurement + +Made after the plan was committed and **before any measurement pass ran**, for a +reason the plan should have anticipated and did not. + +The instrument's timed interval includes **process spawn**. Measured on this +machine: + +| | median | +|---|---| +| `python3 -c pass` | 11.8 ms | +| `/bin/true` | 1.14 ms | + +A Python helper therefore cannot reach the 1, 2, 4 or 8 ms rungs at all — its +floor sits above half the ladder. The helper is consequently written in **C** +(`scripts/round6/spin.c`), compiled once with `-O2`, and identified by the +sha256 of the resulting binary, which the measurement pass re-checks against the +setup pass. C is neither Rust nor Python product code, so the exclusion the +owner ratified is unaffected. + +**The 1 ms rung sits at or below the spawn floor** (~1.25 ms for the compiled +helper). It is kept rather than dropped, and the setup pass marks it +`at_or_below_spawn_floor`. That is a datum, not a defect: it bounds what any +*relative* tolerance can possibly mean at that scale, which is close to the +question this round is asking. + +Timing goes through `perf_baseline.Harness._run_once` — the instrument's own +interval, `perf_counter_ns` around `Popen` and `wait4` — rather than a +re-implementation. Round 6 exists to characterise that interval, and a lookalike +would characterise a different one while the resemblance did the arguing. No +workload is ever passed to the firewall, and no decisive workload appears +anywhere in this round. + +## Per-scale iteration counts (setup pass) + +Filled by the setup pass at `8c61a7b`, before the measurement pass ran. +Helper `f937b36bd4da`, spawn floor **1.332 ms**, +689,052 iterations per ms. Recorded in +`docs/evidence/round6/p022-263a-round6-scales.linux.json`, which lives in a +subdirectory so it is outside the flat report-of-record glob by construction and +not merely by key shape. + +| target ms | iterations | achieved median ms | +|---|---|---| +| 1 | 0 | 1.448 _(at/below spawn floor)_ | +| 2 | 460,280 | 2.0128 | +| 4 | 1,838,383 | 4.09 | +| 8 | 4,594,589 | 8.499 | +| 16 | 10,107,001 | 16.4963 | +| 32 | 21,131,826 | 31.6907 | +| 64 | 43,181,474 | 63.3262 | +| 128 | 87,280,771 | 127.3134 | + +The ladder tracks its targets from 2 ms up. The 1 ms rung is the spawn floor and +is kept, flagged, and read as a bound rather than a duration. + + +--- + +# Reading — decided by the table above, not by what would be convenient + +**Outcome: O2.** The ladder is stable exactly where the real Rust invocations +wander. **An absolute floor must NOT be introduced**, and Round 6 has not found +the cause. + +## What the ladder did + +Absolute median shift, per rung, over five A/B sessions each: + +| target | n=5 median | n=15 median | n=5 relative | n=15 relative | +|---|---|---|---|---| +| 1 ms *(floor)* | 0.056 ms | 0.066 ms | 0.0371 | 0.0464 | +| 2 ms | 0.093 ms | 0.093 ms | 0.0472 | 0.0432 | +| 4 ms | 0.098 ms | 0.071 ms | 0.0247 | 0.0176 | +| 8 ms | 0.053 ms | 0.079 ms | 0.0067 | 0.0100 | +| 16 ms | 0.125 ms | 0.093 ms | 0.0079 | 0.0058 | +| 32 ms | 0.461 ms | 0.105 ms | 0.0142 | 0.0033 | +| 64 ms | 0.459 ms | 0.357 ms | 0.0072 | 0.0056 | +| 128 ms | 1.126 ms | 0.352 ms | 0.0089 | 0.0028 | + +A measurement-scale effect **is** visible: relative shift rises from ~0.006 at +8–16 ms to ~0.04–0.05 at 1–2 ms, which is what a fixed cost divided by a +shrinking denominator looks like. That much of O1's description is real. + +## Formal outcome: O3 (inconclusive). Descriptively O2-like. + +**This section was rewritten after the owner's review rejected a formal O2 +verdict. The rejection was correct and the original reading is withdrawn.** The +dataset is untouched and was not re-run; only the interpretation changes. + +The formal outcome is **O3 — inconclusive**, on the plan's own terms: + +> The dataset is descriptively O2-like, but the preregistration did not +> operationalise the O1/O2 boundary tightly enough to support a formal O2 +> verdict; therefore the preregistered outcome is conservatively O3. The +> observed separation is retained as exploratory calibration evidence and may +> motivate a separately preregistered follow-up. + +### Three ways the original reading exceeded its own plan + +**1. It consulted `0.35`, which the plan forbade in as many words.** The +preregistration says "No pass/fail tolerance is computed, applied, or reported +... `0.35` is not consulted." The withdrawn reading nonetheless observed that the +ladder "never once crossed 0.35" and used that as part of the argument. The +measurement driver never reads `0.35`, so the **dataset is uncontaminated** — +what failed was the interpretation, not the collection. + +**2. O1 and O2 were never operationalised as numbers.** "Roughly constant" and +"stable at 2–8 ms" were written as English, not as decision rules. The +quantities that later did the deciding — a twentyfold growth in absolute drift, +0.3203 ms against 1.23 ms, a factor of 3.9 — were all chosen *after* seeing the +data. They are legitimate **descriptive findings** and they are not a +preregistered boundary. "O2, read off the preregistered table" was therefore a +stronger claim than the plan could support, and it is withdrawn. + +**3. The `A + R*t` fit was performed in a branch that did not license it.** The +plan permits deriving `A` and `R` **only under O1**. The withdrawn reading +selected O2 and then reported the outcome of fitting anyway, comparing the +resulting envelope to `0.35`. Even though no coefficients were published, the +analysis was run where the plan did not allow it. It is quarantined below. + +### What the numbers descriptively show + +Stated as observations, licensing nothing: + +- Absolute drift is **not** constant across the ladder. It grows from 0.056 ms + to 1.126 ms at `n=5`, roughly twentyfold. This is why O1's own precondition, + as written, does not hold — that much is a direct reading of the plan's text + rather than a post-hoc rule. +- A measurement-scale effect is visible: relative shift rises from ~0.006 at + 8–16 ms to ~0.04–0.05 at 1–2 ms, the shape of a fixed cost over a shrinking + denominator. +- In the 2–10 ms band, across 27 A/B sessions, the ladder's worst absolute drift + was **0.3203 ms** and its median relative shift **0.0131**. +- The historical failures in that band implied absolute drifts of 1.23, 1.29, + 1.36, 1.49 and 4.41 ms. + +| failing cell | observed | its median | absolute drift implied | +|---|---|---|---| +| `core-full-human\|rust\|cal-facts-small\|process-cold` | 0.396 | 3.12 ms | 1.23 ms | +| `core-usage\|rust\|cal-facts-tiny\|process-cold` | 0.516 | 2.49 ms | 1.29 ms | +| `core-full-sarif\|rust\|cal-facts-small\|warm` | 0.423 | 3.22 ms | 1.36 ms | +| `core-full-sarif\|rust\|cal-facts-tiny\|process-cold` | 0.508 | 2.93 ms | 1.49 ms | +| `core-full-sarif\|rust\|cal-facts-medium\|process-cold` | 0.478 | 9.22 ms | 4.41 ms | + +The separation between those two groups is large. **It is a reason to keep +looking, not a verdict.** A pure short-duration effect looks insufficient to +explain the failures, and that is the finding worth carrying forward. + +## POST-HOC — NOT PART OF THE PREREGISTERED OUTCOME — NOT POLICY INPUT + +Quarantined rather than deleted, because deleting an analysis that was actually +performed would be its own kind of dishonesty. + +Fitting `A + R*t` to this dataset produces an envelope **tighter** than 0.35 at +these durations. It would reject the Rust cells more often, not fewer. + +This is recorded solely so nobody later reaches for the metrology expecting it +to loosen something. It is **not** evidence for any outcome, it was run in a +branch the plan did not license, and **no coefficient from it may enter any +policy, threshold or envelope.** + +## The boundary of this conclusion + +The helper is a small compiled binary doing pure arithmetic: no file reads, no +document parsing, no large dynamic image to load. `own-cli` is about 1.8 MB and +opens files. The ladder therefore isolates **duration** and does not isolate +**what a real invocation does**. + +**A correction to the original next-suspect list, from the owner.** That list +led with file I/O. It should not have: one of the historical failures is +`core-usage|rust|cal-facts-tiny|process-cold`, and that rung **never opens an +OwnIR document at all** — it starts the Rust core, parses argv, and writes a +usage refusal. Input-document I/O is therefore **not a necessary condition** for +the instability, and the round's own evidence said so while the reading looked +past it. + +The candidates that survive, roughly in order of how cheaply they can be cut: + +| candidate | why | +|---|---| +| executable/library mapping and page faults | `own-cli` is ~1.8 MB; the helper is a few KB | +| dynamic loader / runtime startup | present in a real binary, absent here | +| scheduler: context switches, CPU migration | recorded as a signal in this round but never analysed as a cause | +| CPU-time against wall-time | separates "the machine was busy" from "the work took longer" | +| the output/refusal path | the one thing `core-usage` does that the helper does not | + +**`core-usage` is where the next round should start**: it is the minimal real +Rust process path, it has already produced a witness, and it removes document +parsing from the picture entirely. That is a place to cut causes rather than +re-measure the whole menagerie. + +## What does not change + +Per the preregistration and the owner's standing rulings: no absolute floor, no +v2 envelope, `0.35` unmoved, no `T_min`/`N_min`/`N_max`, no threshold derived +from any number above, and no calibration of record restored. The dataset is +**not** re-run — its provenance is sound and re-running it to obtain a tidier +verdict would be precisely the move this instrument exists to prevent. + +Round 6 stops here, formally inconclusive, with a sharper next question than it +started with. diff --git a/docs/notes/p022-263a-round7-preregistration.md b/docs/notes/p022-263a-round7-preregistration.md new file mode 100644 index 00000000..9769d735 --- /dev/null +++ b/docs/notes/p022-263a-round7-preregistration.md @@ -0,0 +1,713 @@ +# Round 7 — what a real invocation does that a synthetic one does not + +**STATUS: RATIFIED DESIGN. APPARATUS BUILT. B1–B4 PASSED. OUTCOME CONTRACT +BOUND. PLAN-MODE DRY RUN DONE. NO ROUND 7 MEASUREMENT IS AUTHORISED AND NONE +EXISTS.** + +Amended three times. The first review ruled **CHANGES REQUIRED** and decided +four design questions. The second ruled **PASS WITH ONE MECHANICAL CORRECTION** +and ratified a narrower zero rule than the one proposed here. The third reviewed +the implementation, ruled it **PASS**, and then found what the design still did +not say: which bytes get timed, in what order, doing how much work. Those three +gaps are closed below. Timing remains **NO-GO** pending a check of exactly these +bindings. + +**Tag:** `CALIBRATION_ONLY`. No decisive workload, no threshold, no budget, no +D7 freeze. `0.35` is not consulted anywhere in this round, including in the +reading — that was Round 6's defect and it is not repeated. + +## What the owner decided, and where each decision landed + +| question | ruling | where it landed | +|---|---|---| +| extend `_run_once` with full POSIX rusage | **YES** | *What must be recorded*, and the instrument change, now made | +| a fourth, statically linked arm | **NO** | removed; the ladder is A/B/C | +| keep arms A/B/C | **YES** | *Design* | +| measure `process-cold` only, or both regimes | **BOTH** | *Regimes*, classified separately | +| run Round 7 now | **NO** | this status block | + +Four further rulings, none of them a question I had asked: + +- Arm B's claim was too strong and is weakened, with a structural preflight + added. See *Arm B claims less than it did*. +- The previous draft's outcome table was not mutually exclusive. See + *The overlap that made the previous outcome table unreadable*. +- The draft's claim about which witnesses exist was false. See *Correction: the + witnesses are not all `process-cold`*. +- The degenerate-zero guard proposed here was wrong in both directions: the + overlap algebra is narrower than claimed, and the guard was wider. The ratified + rule keys on `A` alone. See *The degenerate-zero guard, as ratified*. + +## The apparatus + +| file | what it is | +|---|---| +| `scripts/round7/classify.py` | the **one** implementation of P1–P5 and the zero-A guard. Pure: numbers in, an outcome out, no files and no clock. Nothing else in the round may restate the rules — a second copy is a second opinion, and the reading would then be able to choose | +| `scripts/round7/elfread.py` | a minimal ELF64 reader, so the preflight reads program and section headers rather than grepping a tool's prose about them | +| `scripts/round7/pad.c` | arm B's inert image, and only that: no function, no code, never referenced by the work | +| `scripts/round7/preflight.py` | builds the three arms and runs B1–B4. No clock, and none may be added | +| `tests/test_round7_apparatus.py` | five controls, run in CI | + +Arm A and arm B are linked from **the same `spin.o`**. Compiling the work twice +and comparing would test the compiler's determinism; linking one object into +both binaries removes the question instead of answering it, and B4 then checks +the only thing left that could differ — what the linker did. + +## What Round 6 left + +Round 6 was formally **O3, inconclusive**. Descriptively, its ladder was stable +at the durations where real `rust` cells fail: worst absolute drift 0.32 ms +across 27 sessions at 2–10 ms, against 1.23–4.41 ms implied by the historical +failures. Short duration alone does not look sufficient. + +The owner's correction to the follow-up: **it is not file I/O.** One of the +witnesses is `core-usage|rust|cal-facts-tiny|process-cold`, and that rung never +opens an OwnIR document — it starts the Rust core, parses argv, and writes a +usage refusal. Input-document I/O is therefore not a necessary condition. + +### Correction: the witnesses are not all `process-cold` + +The previous draft said the phenomenon lives "only in `process-cold`, where +every witness lives". That is false, and the owner caught it. The five distinct +cells that have fallen outside tolerance at least once are: + +| witness | regime | +|---|---| +| `core-full-human\|rust\|cal-facts-small` | `process-cold` | +| `core-usage\|rust\|cal-facts-tiny` | `process-cold` | +| **`core-full-sarif\|rust\|cal-facts-small`** | **`warm`** | +| `core-full-sarif\|rust\|cal-facts-tiny` | `process-cold` | +| `core-full-sarif\|rust\|cal-facts-medium` | `process-cold` | + +One of five is `warm`. A round that measured `process-cold` alone would have +been designed around a claim its own evidence contradicts, and would have +reported a `process-cold`-only result as if it covered the phenomenon. + +## The question, and why `core-usage` is the right place to ask it + +`core-usage` is the **minimal real Rust process path**: no document, no parse, no +analysis, no render of findings. It has already produced a witness. Everything +that distinguishes it from the Round 6 helper is a candidate, and there are few +enough of them to separate. + +| | Round 6 helper | `core-usage` | +|---|---|---| +| image | ~16 KB | ~1.84 MB | +| linkage | dynamic, libc only | dynamic, PIE, `ld-linux-x86-64` | +| work | fixed arithmetic loop | argv parse, usage refusal on **stdout** | +| document I/O | none | **none** | + +## Design: a ladder of process *shapes* at one duration + +Round 6 varied duration and held shape fixed. Round 7 does the opposite. + +| arm | binary | isolates | +|---|---|---| +| **A** `synth` | the Round 6 C helper, at its 2 ms rung | the known-stable baseline | +| **B** `synth-padded` | the same helper, work byte-identical, padded with an inert mapped array to `core-usage`'s image size | the **padded image footprint and its mapping metadata**, with the work held constant | +| **C** `core-usage` | `own-cli ownir` with no arguments, exit 2 | the real witness, whole | + +The decomposition: + +- `D(C) − D(A)` — the total excess to be explained +- `D(B) − D(A)` — what a **larger image costs when its extra pages are never + touched** +- `D(C) − D(B)` — everything else the real binary does: loader symbol + resolution, runtime startup, argv handling, the refusal write, and any cost of + its extra pages actually being touched + +### The static fourth arm is dropped + +The previous draft proposed a statically linked B to separate the dynamic loader +from image size. The owner ruled **NO**. It is not carried forward as a +possibility, a stretch goal, or a footnote; if the loader needs isolating, that +is a later round with its own preregistration. + +### A future arm, named so it is not mistaken for this round's + +`own-cli --version` would be a **same-binary** arm: identical image, identical +loader, less work. It would separate "the binary is big" from "the binary does +things" without a synthetic stand-in at all. It is **not** part of Round 7 and +is recorded here only so that a later round can find the idea rather than +reinvent it as a mid-round improvisation. + +## Arm B claims less than it did + +The previous draft said arm B isolates "image size, mapping and **page-fault +cost**". That was wrong and the owner rejected it. + +Linux demand-pages an executable image. Padding that is mapped but never read +need not be faulted in at all. Arm B therefore does **not** measure page-fault +cost; it measures what it costs to construct, map and account for a larger +image whose extra pages stay cold. + +That makes `D(B) − D(A)` a **lower bound** on any image-related effect, and it +fixes the reading in one specific place: + +> If arm B reproduces nothing, the conclusion is **"a padding-only image effect +> is insufficient"**, *not* "image mapping and page faults are excluded". +> A real binary's extra pages are touched; arm B's are not, and the difference +> between those two situations is exactly what arm B cannot see. + +### Structural preflight for arm B, run and recorded before any timing + +Arm B is worthless if the padding was optimised away, left unmapped, sized +wrongly, or accompanied by a change to the work. Each of those is checked +structurally, on the linked binary, before the measurement pass: + +| preflight | what is checked, on the linked ELF | +|---|---| +| **B1 padding survived linking** | the padding symbol is present in the symbol table, and its containing section's size is at least the declared padding size. Declared `const volatile` so neither the compiler nor `--gc-sections` may drop it. | +| **B2 padding is mapped** | the containing section falls entirely inside a `PT_LOAD` program header. Padding present in the file but outside every `PT_LOAD` is not mapped and does not test what B exists to test. | +| **B3 size matches arm C** | the summed `p_memsz` of B's `PT_LOAD` segments matches C's to within one 4 KiB page. The file sizes are recorded alongside, but the mapped size is the one that must match. | +| **B4 the work is identical to arm A** | the work function's bytes are extracted from each binary by symbol offset and size and compared by sha256. Where relocations make raw bytes differ, address-stripped disassembly equality is used instead **and the reading says which test was applied**. | + +All four are recorded as data, pass or fail. **B1–B4 are stop conditions:** if +any fails, the round does not proceed to timing. In particular, if B3's mapped +sizes cannot be brought within one page by tuning the padding array, the +achieved delta is recorded and the round **stops for a ruling** rather than +running with a mismatched arm and describing the mismatch afterwards. + +## Regimes: both, and what each one actually is + +The owner ruled **BOTH**, and corrected what I had assumed the regimes were. +Both are checked against the instrument, not against memory +(`scripts/perf_baseline.py`, `Harness.measure_cell`): + +| regime | discarded iterations | process | +|---|---|---| +| `process-cold` | **0** | a fresh process every iteration | +| `warm` | **2** | a fresh process every iteration | + +`warm` is **not** an in-process steady state and `process-cold` is **not** a +cold machine. Both spawn a fresh process per iteration. The only difference is +that `warm` throws the first two away, which warms the OS and filesystem caches +rather than any state inside the process. The previous draft's description +contradicted itself on this and is replaced. + +Consequences fixed now, before any data: + +- Each regime is classified **independently**, producing a pair of outcomes + `(P_cold, P_warm)`. +- If `P_cold ≠ P_warm`, that is **not** P5. It is a cache- and state-sensitivity + signal, and it is reported as one, naming both outcomes. A regime split is a + finding about where the phenomenon lives, and collapsing it into "inconclusive" + would discard the most informative thing the round can produce. +- The `n=5` / `n=15` agreement requirement below applies **within** a regime. + +## What must be recorded, and the instrument change it required + +Per run, from the kernel's own per-child accounting: + +`elapsed_ns`, `rc`, `peak_rss_bytes`, `cpu_user_ns`, `cpu_system_ns`, +`minor_faults`, `major_faults`, `voluntary_context_switches`, +`involuntary_context_switches`. + +`Harness._run_once` previously discarded every rusage field except `ru_maxrss`. +The owner authorised extending it, under four constraints, all of which the +implementation honours: + +1. `ru_utime` and `ru_stime` are normalised to **nanoseconds** (rounded, not + truncated: truncation biases every sample the same direction). +2. The measured interval is **unchanged in meaning** — `t0`, `Popen`, `wait4`, + `elapsed` — and the rusage is parsed **after** the clock stops. The two + pre-existing lines between `wait4` and `elapsed` were left where they were: + moving them would tighten the interval and silently un-compare every future + number against every recorded one. +3. Nothing is hashed, forked or verified inside the interval. The existing + `perf-notary-outside` control counts this rather than trusting it. +4. **Off POSIX these six counters are `null` with a stated reason, never zero.** + There is no Windows equivalent that means the same thing, and a reported `0` + minor-fault count for a platform that was never asked would be the most + confident possible lie. `perf-child-accounting` exercises that branch on + Linux by driving the harness through the non-POSIX path. + +This **moves the harness digest** and stales any pair recorded before it. That +was declared in the previous draft as a cost of approval; approval was given and +the change is made. The four committed sizing halves remain stale and are +deliberately not re-recorded. + +## Session structure, and a naming collision fixed + +The previous draft called the two halves of a measurement session "A" and "B" +while also calling the arms "A", "B" and "C". A reading written in that notation +would have been unreadable at exactly the moment it mattered. + +**Arms** are A, B, C. **Session halves** are the *first half* and the *second +half*. A session runs one arm twice, back to back, under one repetition count +and one regime. + +Let `D(arm, n, regime)` be the **median across the 10 sessions** of +`|median(second half) − median(first half)|`. + +Fixed in advance: `n` in {5, 15}, `warmup` 2 (used only by `warm`), **10 +independent sessions per (arm, n, regime)**. + +| | count | +|---|---| +| session halves | 3 arms × 2 counts × 2 regimes × 10 sessions × 2 halves = **240** | +| process spawns, `process-cold` | 3 × 10 × 2 × (5 + 15) = 1200 | +| process spawns, `warm` | 3 × 10 × 2 × (7 + 17) = 1440 | +| **total process spawns** | **2640** | + +Ten sessions rather than Round 6's five because this round compares arms against +each other, not a single arm against a memory. + +`schedule.process_spawns()` **computes** 2640 from the plan, and a control +compares the two. A number quoted in a document and calculated nowhere is a +number that drifts the first time anything around it changes. + +## The execution contract + +The design said what to measure and what the numbers would mean. It did not say +which bytes get timed, in what order, or doing how much work — three holes that +no amount of correct classification would have covered. + +### Which bytes: one transaction, not two + +`scripts/round7/runner.py` does this and nothing else: + + bind work iterations to the Round 6 2 ms rung + ↓ + build arm A and arm B ONCE + ↓ + B1–B4 on THOSE EXACT FILES + ↓ + freeze sha256 and byte length of A, B and C + ↓ + [plan mode returns here, before any clock] + ↓ + time THOSE SAME FILES, re-verifying identity before every block + ↓ + re-verify identity after the last block + +The committed preflight proves properties of specific bytes. A runner that +preflighted, discarded its temporary directory, rebuilt and then measured would +prove things about one pair of arms and time a different pair sharing their +names — this project's oldest and most familiar defect, wearing a lab coat. + +Identity is re-verified **before every block and after the last**: 41 checks, +all outside the clock, against the alternative of discovering mid-dataset that +something rebuilt an arm underneath the round. + +**Plan mode is not a flag that skips the timing loop.** It returns before the +timing function is reachable, and `round7-execution-contract` counts calls to +that function rather than believing this paragraph. Under a mutation that +deletes the early return, the count comes back 240. + +### In what order: blocked randomisation, seeded before the data + +The previous draft fixed how many sessions and halves and said nothing about +order. Run every A, then every B, then every C, and a machine that drifts over +an hour hands back a beautiful "effect of the real binary" — a result that would +survive every other check in this document. + +The ratified schedule: + +| | | +|---|---| +| block | `(regime, n, session)` — 2 × 2 × 10 = **40 blocks** | +| within a block | all three arms run, each arm's two halves **adjacent**, arm order deterministically shuffled | +| across blocks | block order deterministically shuffled | +| seed | fixed and committed before any measurement | +| recorded | seed, planned order, **and actual order** | + +Blocked rather than a Latin square: drift is spread across arms instead of +aligning with them, and every block contains all three arms, so a within-block +comparison is never a comparison across an hour of machine time. + +**The seed is `0xf937b36bd4dac422`** — the first 16 hex digits of the Round 6 +helper's sha256, as committed in +`docs/evidence/round6/p022-263a-round6-scales.linux.json` rounds before this one +existed. A literal I invented would be equally deterministic and strictly less +auditable: nothing but my word would stop me re-rolling it until the order +looked tidy. A control checks the constant against that artifact, and catches a +substituted seed. + +### Doing how much work: bound to the ladder, not to memory + +The draft said "the Round 6 C helper, at its 2 ms rung" and left the number in +prose. It is now read from the artifact that established it: + +| | | +|---|---| +| iterations | **460280** | +| source | `docs/evidence/round6/p022-263a-round6-scales.linux.json`, 2 ms rung | +| Round 6 achieved | 2.0128 ms | +| stop condition | arm A's sha256 must equal that file's `helper_sha256` | + +Arm A as built **is** the Round 6 helper — `f937b36bd4dac422…`, byte-identical, +so nothing needed recalibrating. If a future build ever differs, the round +**stops**. It does not go looking for a fresh iteration count that lands near +2 ms; that would be calibrating a new knob after authorisation, which is the +move this round exists to forbid. + +### And whether the process did the work at all + +Calling `Harness._run_once` directly gave this round the instrument's measured +interval and skipped the layer wrapped around it. That layer exists because +twelve cells once timed `command-not-found` accurately and reproducibly, and CI +called it a reproduced calibration. + +Nothing in Round 7 checked an exit code. Three arms bound byte-for-byte to the +right binaries could have measured the wrong path with great precision — the +sample clamped perfectly in the vice, and nobody checking whether it was alive. + +**Before the clock**, untimed: + +| arm | contract | +|---|---| +| **A**, **B** | invoked with 460280 iterations, must exit **0** | +| **C** | the instrument's own `core-usage` rung — `expect_rc` 2 **and** the `usage-help` evidence: stdout names the subcommand, stderr is empty | + +Arm C reuses `perf_baseline`'s rung rather than restating it a third time. +Exit 2 is necessary and nowhere near sufficient: a different failure exits 2 as +well, which is exactly what the evidence half is for. A control proves this by +handing the preflight a stand-in that exits 2 and prints nothing; it is refused. + +**Every spawn, warmup discards included:** + + A, B → rc must be 0 + C → rc must be 2 + +A single stray exit **stops the round and invalidates it**, recording arm, +block, half, whether it was a warmup or a counted sample, its index and the +observed code. Nothing is classified. A discarded iteration that failed has its +numbers thrown away and its evidence kept: it still proves the process is broken. + +Only the exit code is read inside the interval. Capturing stdout there would +change what the interval measures, which is precisely why the rich contract runs +once, untimed, and the timed samples check rc alone. + +### And a refusal has to leave a black box + +Refusing correctly is not the same as recording the refusal. The breach escaped +`run()`, so `main()` never reached its own `--out` write: 239 halves measured, a +stray exit on the 240th, a traceback, and **no file at all**. Nothing to +investigate, nothing to show anyone. + +The control was no better. It read `exc.strays` out of the exception object and +called that "recorded" — the in-memory sibling of scoring a mutation by its exit +code, and the same lesson this PR keeps paying for: read the thing, not a proxy +for it. + +One boundary handles every `ExecutionContractBreach`, outcome and identity +alike, and writes: + + run_valid: false + measurements: null + verdict: INVALID / STOP () + abort: + kind: outcome-contract | identity-contract + arm, block, half, spawn_kind, index, observed_rc, expected_rc + (identity: when, expected_sha256, observed_sha256) + +Halves already completed are kept as `partial_measurements`, flagged +`not_evidence: true` with the reason attached. They exist for investigation and +may never be read as data, classified, or compared against anything. + +`time_half` now raises on the **first** stray rather than finishing the half. +Once a breach is known, more spawns only produce numbers nobody may use. + +`round7-durable-refusal` never looks at an exception. It drives the runner to a +forced stray and to a **real** mid-run identity drift — arm B's bytes genuinely +changed on disk, caught by the real verifier — and then reads the filesystem: +the file exists, the exit code is non-zero, `run_valid` is false, `measurements` +is null, and the abort names the exact spawn or arm. It also checks a healthy +run still calls itself valid, so the control cannot pass by calling everything +invalid. + +## The overlap that made the previous outcome table unreadable + +The owner found that the previous table's P1 and P4 could both fire on the same +data: `D(A)=1, D(B)=3, D(C)=1.4` satisfies P4 (`D(C) ≤ 1.5·D(A)`) and P1 +(`D(B) ≥ 3·D(A)` and `D(C) ≤ 1.5·D(B)`) simultaneously. Ten rounds of insisting +that a check must read the thing, and I preregistered the numbers and forgot to +preregister the logic. + +### And then I got the replacement's algebra wrong too + +The previous revision of this section claimed that "every overlap between two +rules reduces to `D(A) = 0` or `D(B) = 0`". The owner did the algebra properly +and it does not. The claim "I checked every pair" was again stronger than the +checking behind it. + +**Overlap occurs only when `A = 0` AND `B = 0` together.** In particular: + +| pair | what the constraints force | +|---|---| +| P4 ∩ P1 | empty for all inputs: P4 needs `C ≤ 1.5A`, P1 needs `C > 1.5A` | +| P1 ∩ P2 | forces `A = 0`, then `B = 0`, then `C = 0`, contradicting P1's `C > 1.5A` — **empty** | +| P1 ∩ P3 | forces `B = 0`, then `A = 0` and `C = 0`, contradicting `C > 1.5A` — **empty** | +| P4 ∩ P2 | `A = B = C = 0` | +| P4 ∩ P3 | `A = B = C = 0` | +| P2 ∩ P3 | `A = B = 0`, with `C` free | + +So **P1 is disjoint from every other rule unconditionally**, the zero case +included. The overlaps that remain all need `A` and `B` to be zero together. + +This is no longer asserted. `round7-outcome-exclusivity` evaluates the rules +over 50,653 exact rational triples and reports which pairs overlap and where; +the same census is handed the previous draft's P1 and must report it broken, +because a control that has only ever seen correct input is a control nobody has +tested. + +## Outcome set, as ratified by the owner + +Evaluated per regime, per repetition count. `A`, `B`, `C` abbreviate +`D(A, n, regime)`, `D(B, n, regime)`, `D(C, n, regime)`. + +| outcome | rule | what it licenses | +|---|---|---| +| **P4** the witness did not reproduce | `C ≤ 1.5·A` | the round failed to capture the phenomenon in this regime; report and stop | +| **P1** the padded-image effect reproduces the elevation | `C > 1.5·A` **and** `B ≥ 3·A` **and** `(2/3)·B ≤ C ≤ 1.5·B` | a padded image alone lands where the real binary lands; a follow-up may target image construction and mapping | +| **P2** the padding-only effect is insufficient, the real binary is elevated | `B ≤ 1.5·A` **and** `C ≥ 3·A` | the excess is not reproduced by size alone. **This does not exclude image mapping or page faults** — see *Arm B claims less than it did*. | +| **P3** padding contributes but does not explain the whole | `B ≥ 3·A` **and** `C ≥ 2·B` | neither alone explains it | +| **P5** inconclusive | everything else, **or** `n=5` and `n=15` classify differently within this regime | nothing; report and stop | + +Note the renames from the previous draft, which the owner required: P1 is no +longer "image mapping dominates" and P2 is no longer "not image mapping". Both +old names asserted more than arm B can see. + +**A rule must hold at both `n=5` and `n=15` within a regime to fire.** If the +two counts disagree, that regime's outcome is **P5**. Disagreement *between* +regimes is reported as a cache/state-sensitivity signal, not as P5. + +### The degenerate-zero guard, as ratified + +> For each regime: if `D(A) = 0` at **either** repetition count, that regime's +> outcome is **P5**. + +`A` only. Not `A` or `B`, which is what the previous revision proposed and the +owner rejected. + +**The guard is not what makes the set disjoint.** The algebra above shows the +overlaps need `A = 0` and `B = 0` together, so a rule keyed on `A` alone is +already more conservative than exclusivity requires. The guard exists for a +metrological reason instead: `A` is the **multiplicative reference** for the +whole scheme. `1.5A`, `3A` and `6A` mean something only as multiples of a +baseline that has a size. At `A = 0` any positive `B` or `C` is infinitely +larger than the baseline, and the rules go on classifying — definitely, and +meaninglessly. + +**`B = 0` has no such property and is not a refusal.** `A = 1, B = 0, C = 4` is +a clean **P2**: the padded arm shows no excess and the real binary does. That is +one of the cleanest results this round is capable of producing, and the rejected +guard would have deleted it by hand. + +**No epsilon.** A tolerance like `A < 0.01 ms` would instantly become a new +absolute threshold with no preregistered basis for its value, which is the exact +move this round forbids. Exact zero is a structural degenerate case, not another +knob. `round7-zero-guard` checks both halves: `A = 0` at either count refuses, +and a tiny but non-zero `A` still classifies. + +### Why ratios and not absolute milliseconds + +An absolute boundary would have to come from somewhere. The only available +sources are the failing Owen cells, which are forbidden as input to any rule, or +a number invented to fit, which is worse. A ratio against a baseline arm +measured in the same sessions is self-calibrating and cannot import a threshold +by accident. + +### Mechanism attribution, also fixed now + +Applied only to whichever arm shows elevation, only after an outcome fires, and +per regime. `Δ` is `second half − first half` within a session; each row is a +median across the ten sessions. + +| attribution | rule | +|---|---| +| the work genuinely took longer | median `\|Δ(cpu_user_ns + cpu_system_ns)\|` ≥ `0.5 ×` median `\|Δ elapsed_ns\|` for that arm | +| scheduler | median `\|Δ elapsed_ns\|` ≥ `2 ×` median `\|Δ(cpu_user_ns + cpu_system_ns)\|` **and** median `\|Δ(voluntary + involuntary context switches)\|` **> 0** **and** ≥ `2 ×` arm A's | +| faults / mapping | median `\|Δ(minor_faults + major_faults)\|` **> 0** **and** ≥ `2 ×` arm A's | + +applied only when median `\|Δ elapsed_ns\|` **> 0** for that arm. + +More than one may fire. None firing is itself a reportable result: it would mean +the drift is visible in wall time and in none of the accounting the kernel +offers, which is worth knowing. + +### The zero-versus-zero hole, corrected + +Every rule above is a ratio against a quantity that can itself be zero, and +`0 ≥ 2 × 0` is true. As originally written, a cell where **nothing moved** — +zero wall drift, zero CPU delta, zero context switches, zero faults — fired +**all three** mechanisms: a confident attribution of a drift that does not +exist. The owner found it by reading the rule rather than by running it. + +Two of the three guards are the owner's, stated as ratified: the context-switch +predicate and the fault predicate each now require a **strictly positive** +median before the ratio is consulted. + +The third is mine and is flagged as such: attribution is applied only when the +arm's median `|Δ elapsed_ns|` is **> 0**. The `work` rule degenerates the same +way (`0 ≥ 0.5 × 0`) and the owner's two guards do not cover it. This +precondition is the smallest statement that makes all three refuse the null case +coherently — if there is no wall-clock drift there is nothing to attribute — and +it cannot change any outcome in which a drift actually exists. It is an addition +to the ratified table and the owner may strike it. + +This hole never fired in the recorded round: `process-cold` classified P4 and +`warm` P5, and neither licenses any attribution, so the committed reading is +**byte-identical** before and after the correction. It was latent, not active. + +## Explicitly forbidden + +- Consulting, reporting or comparing against `0.35`, anywhere, including in the + reading. This is Round 6's defect and it does not recur. +- Deriving any threshold, budget, floor or envelope from any number produced + here. +- Using the Owen failing cells as input to any rule. They are the phenomenon + being explained, not a calibration source. +- Choosing `T_min`, `N_min`, `N_max`, moving `--warmup`, or using any repetition + count other than 5 and 15. +- Adding a fourth arm, static or otherwise, mid-round. +- Reading a P2 as "image mapping and page faults are excluded". +- Any decisive workload, decisive timing, resource exposure of decisive work, + D7 threshold, C1/C2 freeze, #263-B, Stage 3 or Stage 4. +- Reporting an outcome not produced by the table above. If the numbers are + suggestive but no rule fires, the outcome is **P5** and the suggestion is + recorded as exploratory, not as a verdict. + +## Stop rules + +- Any of preflight **B1–B4** failing: stop before timing. A padded binary whose + padding was dropped, unmapped, mis-sized or accompanied by a work change + confounds the two things arm B exists to separate. +- **P4** in both regimes: stop and report. Do not enlarge the ladder hunting for + the phenomenon. +- **P4** or **P5** in a regime: stop after reporting for that regime. Neither + licenses a policy change. + +## Deliverables + +- The three arm binaries' sha256s, file sizes and summed `PT_LOAD` `p_memsz`, + recorded before the measurement pass. **Done** — + `docs/evidence/round7/p022-263a-round7-preflight.linux.json`. +- The B1–B4 preflight results, recorded as data, pass or fail. **Done**: all four + pass. The padding is 1,626,024 bytes in `.rodata`, inside the `PT_LOAD` at + `0x2000`; arm B maps 1,628,917 bytes against arm C's 1,628,892, a difference of + **+25 bytes** against a 4,096-byte allowance; and `main` is 107 bytes and + byte-identical in both arms, so B4 decided on raw bytes and the disassembly + fallback was not needed. +- A committed dataset with every raw observation and every accounting field, per + half, per session, per regime, per repetition count. +- A reading that names which rule fired in each regime, quoting the arithmetic, + and nothing beyond it. + +## The pass ran. The formal outcome is (P4, P5). + +The owner authorised **one** `CALIBRATION_ONLY` pass, pinned literally to head +`7ad4a0b627d95221cfbb9831847eec7288a8daef`, with no automatic retries under any +failure. It ran once, at 07:03 UTC on 2026-09-11, on that head with a clean +tree, and came back `run_valid: true`: 240 halves, 2640 spawns, no stray exit +code, no identity drift, no stop condition. + +The spawn accounting, stated exactly: **2400 retained samples** — 1600 at rc 0 +for arms A and B, 800 at rc 2 for arm C — plus **240 warmup discards** whose +exit codes were checked on the same contract, any stray among them invalidating +the run, and whose rows are deliberately not retained. Discarding them is what +the `warm` regime *is*; retaining them would make the dataset describe a regime +nobody ran. + +### D(arm, n, regime), in milliseconds + +| regime | n | D(A) | D(B) | D(C) | C/A | B/A | +|---|---|---|---|---|---|---| +| `process-cold` | 5 | 0.0623 | 0.0337 | 0.0517 | 0.83 | 0.54 | +| `process-cold` | 15 | 0.0321 | 0.0517 | 0.0343 | 1.07 | 1.61 | +| `warm` | 5 | 0.0509 | 0.0443 | 0.0494 | 0.97 | 0.87 | +| `warm` | 15 | 0.0243 | 0.0484 | 0.0903 | 3.71 | 1.99 | + +### Which rule fired, with the arithmetic + +**`process-cold` is P4 at both counts — the witness did not reproduce.** + + n=5 C = 0.0517 <= 1.5 x 0.0623 = 0.0935 -> P4 + n=15 C = 0.0343 <= 1.5 x 0.0321 = 0.0482 -> P4 + +P4 held at n=5 and n=15, so the regime is **P4**. + +**`warm` is P5 — the counts disagree.** + + n=5 C = 0.0494 <= 1.5 x 0.0509 = 0.0764 -> P4 + n=15 C = 0.0903 > 1.5 x 0.0243 = 0.0365 -> not P4 + B = 0.0484 < 3 x 0.0243 = 0.0729 -> not P1, not P3 + B = 0.0484 > 1.5 x 0.0243 = 0.0365 -> not P2 + -> P5 + +A rule must hold at both counts within a regime to fire. P4 at n=5 and P5 at +n=15 is disagreement, so the regime is **P5**. + +The cold/warm difference is reported as a **split**, not collapsed to P5: both +regimes spawn a fresh process per iteration and differ only in whether the first +two are discarded. + +### The mechanism table was not applied, and that is the rule working + +P4 fires no elevation and P5 fires no rule, so neither regime licenses an +attribution. The reading records that refusal in both regimes with its reason +rather than reporting a table nobody asked for. Attribution after a P5 would be +an analysis the preregistration does not license, and it is exactly the kind of +"the numbers are suggestive, let me just look" move this round forbids. + +### Stop rules, applied + +> **P4** or **P5** in a regime: stop after reporting for that regime. Neither +> licenses a policy change. + +Both regimes hit that rule. The round stops here. No policy value moved, no +threshold was derived, `0.35` was not consulted, no session was dropped, and the +pass was not repeated. There is no second pass and none is authorised. + +### What this does and does not establish + +It establishes that on **this** machine, at **this** work size, with the arms +and schedule fixed in this document, the `n=5`/`n=15` half-to-half drift is +0.024–0.090 ms across all three arms, and that the C-against-A ratio does not +clear the P4 boundary in `process-cold` at either count. + +It does **not** establish why the historical Owen cells failed, does not +exonerate image mapping or page faults, and does not license reading `warm`'s +n=15 numbers as a trend. One cell out of four sitting above the P4 boundary is +what P5 means, and P5 means the round declines to say. + +The reading is committed at +`docs/evidence/round7/p022-263a-round7-reading.linux.json` and the raw dataset, +every retained observation and every accounting field, at +`docs/evidence/round7/p022-263a-round7-dataset.linux.json`. + +### What makes this reading trustworthy, stated without overclaiming + +The operator recorded a pre-clock sha256 of `scripts/round7/readout.py` +(`0f14be8a491d`). **Repository history does not independently establish that +chronology** — the file is absent from the authorised head `7ad4a0b` and enters +the tree in the single post-run commit. An earlier revision of this document +called that provenance "checkable"; it is not, and the claim is withdrawn. + +The result does not depend on it. Everything that decides the outcome was frozen +in this document before any measurement existed: the definition of `D`, the +P1–P5 rules, the zero-A guard, the attribution gates and the stop rule. +`readout.py` delegates every classification decision to `classify.py` rather +than restating it, so a reading written entirely after the fact would still have +had to produce this answer. `round7-readout` recomputes the committed reading +from the committed dataset on every CI run, on both platforms. + +## Authorisation state + +**Authorised and done:** all four amendments; the `_run_once` extension; the +apparatus; the B1–B4 structural preflight; the execution contract, schedule and +work binding; the **outcome contract**, timed and untimed; the **plan-mode dry +run**; the **single `CALIBRATION_ONLY` measurement pass**; the preregistered +reading; controls and mutations; CI. + +**Not authorised:** a second measurement pass, for any reason including a +failed first one; re-recording the sizing pairs; a calibration of record; the +D7 freeze; #263-B; merge; Stage 3; Stage 4. + +The plan-mode record is committed at +`docs/evidence/round7/p022-263a-round7-plan.linux.json`: arms built, B1–B4 +passed on those bytes, identities frozen, the untimed outcome preflight passed +for all three arms (A 0, B 0, C 2 with evidence), 40 blocks and 240 halves +fixed, zero clocks started. The measurement pass that followed it is recorded +beside it. diff --git a/docs/notes/p022-263a-step7-environment-capture.md b/docs/notes/p022-263a-step7-environment-capture.md new file mode 100644 index 00000000..bb91c02d --- /dev/null +++ b/docs/notes/p022-263a-step7-environment-capture.md @@ -0,0 +1,225 @@ +# P-022 / #263-A — step 7, the measurement-free environment identity manifest + +```text +Status: + STEP 6 TRAINING PREREGISTRATION PASS / CLOSED. + ENVIRONMENT CAPTURE TOOLING AUTHORISED. + ENVIRONMENT PROVISIONING AUTHORISED. + EXECUTION BINDING AUTHORISED. + FIRST STEP-7 CLOCK BLOCKED until dedicated Linux and Windows hosts exist + and the exact binding is frozen against them. + SINGLE STEP-7 COLLECTION AUTHORISED automatically after that gate. + STEP 8 FIT, HOLDOUT, D7 / #263-B NOT AUTHORISED. + NO CLOCK HAS RUN. NO OBSERVATION EXISTS. +``` + +## Why this is a separate tool and not a harness change + +`environment_fingerprint()` in `scripts/perf_baseline.py` records about half of +what the owner's ruling makes identity-bearing. It has CPU model, logical count, +installed RAM, Python version, `rustc`, `dotnet` and `platform.platform()`. It +has no owner-assigned `environment_id`, no host fingerprint, no virtualization +boundary and no power policy, and its OS and kernel detail is only what +`platform.platform()` happens to yield. + +Extending it was refused rather than attempted. `perf_baseline.py` is one of the +two files in the harness source set, so editing it moves +`measurement_harness_digest 562a7f7232da…` — the digest step 4 froze, step 5 +bound its constants to, and step 6 bound its preregistration to. Preparing step 7 +by invalidating the identity steps 4, 5 and 6 were accepted on is a snake eating +its own tail, and the owner named it as such. + +## Where it lives, and why that is not arbitrary + +Three frozen source sets exist, and the tool is outside all of them: + +| set | root | bound by | +|---|---|---| +| harness | `scripts/perf_baseline.py`, `docs/evidence/p022-263a-workloads.json` | steps 4, 5, 6 | +| policy | `scripts/calibration/` | step 4 digest `c3068ed7fa88…` | +| scope | `scripts/training/` | step 6 digest `614bf9efe6ba…` | + +The second and third are computed over **every committed `*.py` under the root**, +so a new file dropped into either would move a digest that is already accepted. +`scripts/training/` was the tempting place and would have broken the step-6 +binding on the first commit. The tool therefore lives in `scripts/step7/`, +following the existing `scripts/round6/` and `scripts/round7/` convention, and +`envcapture-frozen-untouched` recomputes all three digests on every CI run rather +than trusting this paragraph. + +## What it may never do + +No clock and no resource observation: no `perf_counter`, no `monotonic`, no +`wait4`, no `getrusage`, and no timing of the subprocesses it uses to read tool +versions. `memory_bytes` is how much RAM the machine **has**, never how much +anything used. + +It is deliberately self-contained and does not import `perf_baseline`. If it did, +"this file starts no clock" would stop being provable by reading this file, and +the audit would have to follow an import into the very module that exists to +start clocks. + +`envcapture-no-measurement` proves this by walking the **AST**, not the text. The +module's own docstring names `perf_counter` and `wait4` in order to disclaim +them; a text scan would read the prose and call that a finding, which is the same +defect as a check reading a proxy for the thing it checks. The control also +mutates a copy in memory with a real `time.perf_counter()` and requires the +scanner to report it, so its silence on the real module is evidence rather than +an assertion. + +## The two-shape field contract + +Every identity field is exactly one of: + +```json +{"status": "observed", "value": ""} +{"status": "unavailable", "reason": ""} +``` + +There is no third state. An empty string, a zero, a bare boolean, a null, a +missing key and a silent absence are all refused, because the difference between +"unknown" and "zero" is exactly the difference this whole track exists to keep. +The boolean case is explicit: `bool` IS an `int` in Python, so an unguarded +numeric test would have accepted `True` as a CPU count — the Round 9 defect, +which this repository has now paid for once. + +`environment_id` is the one field for which `unavailable` is itself a refusal. It +is assigned by the owner, not discovered, so its absence is an operator error +rather than a property of the machine. + +## Identity versus provenance, which is the owner's ruling made checkable + +| identity — drift invalidates the stratum | provenance — changes freely | +|---|---| +| `environment_id`, `host_fingerprint` | `timestamp_utc` | +| `os_build`, `kernel` | `runner_name` | +| `cpu_model`, `logical_cpu_count`, `memory_bytes` | `workflow_run_id`, `job_id` | +| `virtualization`, `power_policy` | `ci` | +| `python`, `rustc`, `dotnet` | | + +`RUNNER_NAME` names an allocation, not a machine. Making it identity-bearing +turns the protocol into a farce on any orchestrated runner: either the stratum +self-invalidates on the next allocation, or one pretends different machines are +the same one. `envcapture-identity-split` refuses to let it migrate. + +Fields compare **whole**, not by value alone. A field that goes from `observed` +to `unavailable` between runs is drift, and so is a changed reason; reading only +`value` would let an environment go dark unnoticed. + +## The candidate sequence, fixed before any of it happens + +```text +pin source/tree + build recipe/toolchains + v +build candidate on Linux host [UNTIMED] +build candidate on Windows host [UNTIMED] + v +record per-stratum candidate_sha256 and candidate_bytes + v +freeze execution-binding artifact + v +exact-head binding controls + v +FIRST CLOCK +``` + +The two strata will have different SHA and byte length; within a stratum they +must stay identical across all fifteen runs, and a rebuild that changes bytes +after collection starts invalidates that stratum. + +## A caveat recorded rather than papered over + +`host_fingerprint` hashes the running system's machine id. **Inside a container +that is the container's identity, not the host's.** Run on this development +container the tool reports `virtualization: docker`, which is the honest answer +and one more reason the collection runs on a dedicated machine. The manifest +records `ci` and `runner_name` in provenance, and +`envcapture-ci-provenance` proves a manifest taken on a hosted runner says so, +so it cannot later be presented as host-taken. + +## Controls + +```text +envcapture-guard-reports a control that raises is reported, never fatal +envcapture-schema the declared key set, enforced both ways +envcapture-field-contract observed/unavailable, with no third state +envcapture-identity-split provenance can never become identity +envcapture-assigned-id an owner-assigned id cannot be 'unavailable' +envcapture-drift provenance moves freely; identity never does +envcapture-no-measurement no clock, no resource accounting, by AST +envcapture-reason-fits-platform an 'unavailable' reason names THIS platform +envcapture-windows-fixture the schema holds off Linux +envcapture-frozen-untouched this addition moved none of the three frozen digests +envcapture-ci-provenance a CI-taken manifest says so and cannot hide it +``` + +Fifteen mutations, each declaring in advance which control must catch it, and +each scored on a `FAIL` line from **that** control rather than on a non-zero +exit. Two of the fifteen mutate the **control file**, not the tool: the guard is +the durable answer to a defect recorded eight times, so it needs its own +adversary. + +## Two defects the campaign found, both real + +**The schema could lie about itself.** `capture()` built an identity dict and +then projected it through `IDENTITY_FIELDS`. Adding a name to the declared tuple +without adding a collector made it die with `KeyError` — a traceback rather than +a refusal. `_refuse_drift()` now names the mismatch in both directions. + +**A control that crashes before reporting is a traceback, not a finding — the +eighth instance, and this one was mine, in the file written to hold the others to +account.** The mutation that promoted `runner_name` into `IDENTITY_FIELDS` killed +the fixture builder inside the *first* control, so the run died before +`envcapture-identity-split` — the control that owns exactly that defect — could +say a word. The scorer reported MISSED, correctly, because nothing printed a +`FAIL` line. The durable fix is not another resolution to be careful: `guarded()` +turns any escaping exception into a reported failure for that control and lets +the run continue, and `envcapture-guard-reports` makes restoring the bare call a +test failure rather than a story in a session log. + +## What the first Windows CI run found, and what it cost + +The Windows capture path was described as unverified, and one CI run on +`windows-latest` (Server 2025) made most of it verified and found two defects. + +| field | Windows result | +|---|---| +| `host_fingerprint` | observed — the registry `MachineGuid` read works | +| `os_build`, `kernel` | observed — `Windows 2025Server 10.0.26100 SP0 …` | +| `memory_bytes` | observed — `GlobalMemoryStatusEx` works | +| `power_policy` | observed — `powercfg` returns the active scheme | +| `cpu_model` | observed, but **weak** | +| `virtualization` | **unavailable, for a Linux reason** | + +**`virtualization` reported "systemd-detect-virt absent or unclear and no DMI +identity under /sys" — on Windows.** That is true of every Windows machine ever +built, and it reads as though a probe ran when nothing Windows-specific had been +tried at all. A stated reason naming the wrong operating system is worse than no +reason. `_virtualization()` is now platform-branched and queries +`Win32_ComputerSystem` through CIM, and `envcapture-reason-fits-platform` +enforces the general rule: an `unavailable` reason may only name mechanisms that +exist on the platform it was produced on. Designing that control immediately +caught a second instance — `_cpu_model`'s repaired reason named both `/proc/cpuinfo` +and `Win32_Processor` in one sentence. + +**`cpu_model` fell through a dead tool in silence.** `wmic` is gone from recent +Windows images, so the model name arrived as `platform.processor()`'s +`AMD64 Family 25 Model 1 Stepping 1, AuthenticAMD` — a family string, not the +processor's name, and nowhere near the "cpu model exact" the ruling asks for. The +CIM query now runs first. + +**A green run printed a failure.** `control_guard_reports` exercised the guard by +calling it and then deleting the entry from the failure list, which left a literal +`FAIL[envcapture-guard-fixture]` in every passing CI log — exactly the string this +repository's mutation scorer keys on, and the sort of line that teaches readers to +ignore `FAIL`. The guard is now split into a pure `guard_failure()` that returns +the message and a `guarded()` that reports it, so the probe asserts on a returned +string and prints nothing. + +## What is still NOT verified + +Capture on a **dedicated** Windows host. A hosted runner is not one, and the CIM +virtualization query added above has never executed anywhere, since this container +is not Windows. `envcapture-windows-fixture` exercises the schema and drift rule +on a synthetic manifest and now says exactly that rather than claiming the +Windows branches are unrun. diff --git a/docs/notes/p022-263a-training-preregistration.md b/docs/notes/p022-263a-training-preregistration.md new file mode 100644 index 00000000..14fd88c5 --- /dev/null +++ b/docs/notes/p022-263a-training-preregistration.md @@ -0,0 +1,273 @@ +# P-022 / #263-A — training collection preregistration (step 6) + +```text +Status: + TRAINING PREREGISTRATION RECORDED. + NO TRAINING COLLECTION HAS RUN. + NO EMPIRICAL CONSTANT EXISTS. + STEP 7 COLLECTION NOT AUTHORISED. + STEP 8 FIT NOT AUTHORISED. + HOLDOUT NOT AUTHORISED. +``` + +This document and `docs/evidence/calibration/p022-263a-training-preregistration.json` +fix the protocol of a training collection **that has not happened**. Step 6 contains +no clock, no observation, no fitted `A_abs` or `R_rel`, no selected `N` and no +width. It changes neither the frozen policy nor the measurement harness. + +## The gap this step closed, and where it was + +The owner's review found that platform had fallen between two levels of the model +rather than out of a report. Ratified §2.1 defines a cell as the four-part +`(rung, engine, workload, regime)` and says *no finer*. §3.3 then pools every cell +of the named universe into one fit per rung, and §3.4 turns that into one width and +one selected `N`. Meanwhile the instrument requires both Linux and Windows, and +§6.5 makes environment part of comparability while recording that a GitHub-hosted +runner has already shown itself not measurement-grade. + +Nothing in the ratified text said whether the universe spans platforms. Three +readings all survived every sentence, and they disagree about whether an unstable +machine widens the bound a stable one must then live under. That is a statistical +model decision, so it went to the owner rather than being chosen here. + +## The owner's ruling + +**Platform is not a fifth cell axis.** The frozen four-part identity is unchanged. +Platform is an **outer training stratum**, and there are exactly two universes, +`U_linux` and `U_windows`. + +Within a stratum, cold and warm remain distinct cells and every cell pools into one +fit per rung by the frozen fitter, unchanged. Across strata, observations, medians, +envelopes and widths are **never** pooled, averaged or summed. The result is +`E_p,N` and `W_p(N)` per platform, rather than one envelope inflated by the noisier +runner into a forgiving blanket. + +**One global `N` all the same.** Each stratum computes its own admissible set + + Q_p = { N in the ladder : W_p(N) <= (1 + G) * min_N W_p(N) } + +and the selection is the smallest ladder rung in `Q_linux ∩ Q_windows`. Three +alternatives are rejected by name. `max` of the per-stratum picks looks conservative +for about twenty seconds and can select a rung admissible under neither stratum's +margin. Averaging the widths lets an unstable platform buy a stable one a wider +tolerance with its own instability. Treating one platform as the reference puts the +other into D7 with no measurement model of its own. + +**Empty intersection is a stop.** `NO_COMMON_N` is an **orchestration** refusal, not +a fifth reproducibility verdict: the frozen four describe cells and run pairs and +are untouched. There is no fallback rung, no stricter-platform tie-break, no second +`G` and no second fit. + +## The combiner, and the one thing it refuses to do + +`scripts/training/scope.py` exists because `Q_linux ∩ Q_windows` is code that takes +a statistical decision, and §3.6 requires such code to be written and +provenance-bound **before** the data it will judge. It lives outside +`scripts/calibration/` deliberately: the step 4 control proves the frozen root grew +no new file, and it would stop proving that if this landed inside it. + +**It does not re-implement the `(1 + G)` test.** The frozen `select_n` already +computes the margin and reports `widths` and `limit` beside its own pick, so `Q_p` +is read back off that result. A second copy of the margin arithmetic would only ever +prove that the two copies agree, which is the defect this PR has spent thirteen +rounds removing. `training-scope-admissible` proves the reading is real rather than +incidental: it perturbs the `limit` the frozen function reported and requires the +combiner's answer to move. A combiner that recomputed the margin itself would ignore +that and pass. + +On `NO_COMMON_N` the result carries **no** `selected_n` key at all, so a caller that +reads it without checking the outcome raises `KeyError` rather than proceeding on a +number the rule did not select. + +### A control that could not tell a traceback from a finding, for the seventh time + +`training-scope-refusals` was first written with a helper that caught bare +`Exception` and scored that as a refusal. Under the mutation that deletes the +strata-versus-selections check, the combiner then raised `KeyError` reaching for a +stratum that was not there, and the helper read that crash as the guard working. +The mutation came back MISSED, which is the only reason it was found. + +This is the same family the ledger already records six times, in a file written +after all six. The helper now returns empty only for a refusal raised **by name**, +and reports anything else as the defect it is. Recorded rather than quietly fixed, +because the interval between knowing this lesson by heart and writing it wrong +again was, this time, about forty minutes. + +## The forgotten stopwatch + +The first version of this step was reviewed CHANGES REQUIRED, and the finding was +not in anything it added. It was in what CI had been doing all along. + +The legacy calibration pair still ran in the same job: two real `--calibrate` runs +per platform, forty timed cells each, uploaded as workflow artifacts, on the very +commit whose preregistration said it took no new observation. "Step 7 has not run" +stayed true. "Step 6 produced no new timing or resource observation" did not, and +those are different sentences. I had checked that my own commit contained no clock +and never checked what the job I was extending already did. + +That is worse than an idle diagnostic, because of what this document does. Once a +preregistration fixes **exactly one** collection and forbids choosing among +attempts, a CI job gathering numbers every twelve minutes is an epistemic side +channel whoever owns it and whatever they mean to do with the output. + +**The rule is now unconditional**, and deliberately not phrased about dates: + +> Every timing/resource observation produced outside the single owner-authorised +> Step-7 training collection is permanently inadmissible as fitting, N-selection, +> holdout, or D7 evidence, regardless of whether it predates or postdates this +> preregistration. + +The earlier wording excluded only data recorded *before* this document, which would +have readmitted whatever a later rerun produced, on the entirely sincere ground +that it is just a diagnostic. The run 2038 artifacts from both platforms are +recorded in the artifact as `POST_PREREG_LEGACY_DIAGNOSTIC`, +`INADMISSIBLE_FOR_TRAINING`, `NEVER_FIT`, `NEVER_SELECT_N`. + +**The timed pair is gone from CI** while step 7 is closed, along with the step that +read its report and the step that uploaded it. What still proves the apparatus is +untimed and unchanged: the instrument selftest, the instrument controls, the round 7 +apparatus controls, the round 7 runner in plan mode, the decisive structural smoke, +and the policy, freeze, constants and preregistration controls. + +**And the boundary is mechanical now, not remembered.** +`training-no-incidental-measurement` scans every executable line of every workflow +and fails if any reaches `perf_baseline.py --calibrate` or `runner.py --measure` +while the artifact still records step 7 as unauthorised. It reads that state from +the preregistration rather than from a constant here, so authorising step 7 is what +relaxes it, and nothing else. It also asserts both guarded flags still exist: a +control that passed because a flag had been renamed would be the proxy defect one +more time. A shell comment naming an entrypoint is allowed, because a comment +cannot execute. + +Four mutations, each caught by that control or correctly allowed: the pair added +back to `ci.yml`, an entrypoint appearing in a *different* workflow, the flag +renamed out from under the guard, and a comment that merely mentions it. + +### The same guard, with its polarity reversed + +The first version of that control was reviewed FAIL-OPEN, and the finding was one +operator. It read `!= "NOT AUTHORISED"` and then returned **OK**, so the state +machine was really this: + + the exact refusal -> gate closed + everything else -> gate open + +A typo, a missing key after some later schema change, `null`, a `True`, the +American spelling, or simply the word `AUTHORISED` all meant permission to start a +clock. The enumerated schema did not save it either: that control proved the key +was *allowed to exist*, never what its value meant. Driven rather than argued, the +old code passed with `step_7_collection` set to `AUTHORISED` **and** a real timed +step added to `ci.yml`, announcing that it was standing down. The artifact could +authorise its own stopwatch by editing one string. + +It now accepts exactly one state and fails on everything else, and there is +deliberately **no authorised branch at all**. Step 6 is a preregistration and +cannot open step 7: when step 7 is really authorised, a separate reviewed artifact +and a separate owner decision change the orchestration, rather than this document +mutating into a permission bit its own producer can flip. The permitted state is +also pinned as a frozen literal by the schema control, so two controls fail rather +than one. Nine mutations: the key missing, `AUTHORISED`, `AUTHORISEDD`, `null`, +`NOT AUTHORIZED`, `not authorised`, a space-padded copy, a boolean, and the +worst case of a claimed authorisation alongside a real timed step. + +### And a second fail-open in the same control, found at re-review + +The polarity fix was right and did not save the scan beside it. That scan required +the command name and the forbidden flag on the **same physical line**: + + if name in line and flag in line: + +The repository's own Round 7 invocation is written across four lines, with +`--plan` on a continuation line by itself. Change that one word to `--measure` and +the line naming the script carries no flag while the line carrying the flag names +no script. Driven rather than argued: the mutation on the real block came back +MISSED, and the flag-existence check passed too, because nothing had been renamed. +A plan-only step becomes a real measurement by editing one word, and the guard +stays green. The safety mechanism was defeated by a line break. + +The scan now matches the **flag alone**, with no coupling to any command name. +While step 7 is shut a capability token may not appear in executable workflow text +at all, wherever it is and whatever sits beside it, so continuations, variables and +quoting cannot get between the guard and the thing it guards. That is stricter than +naming invocations, and strictness is the correct default for this phase. Building +a shell parser to decide which occurrences *really* invoke something would be a +remarkably human way to answer a three-line problem with a small compiler. + +Six cases, each caught or correctly allowed: the real Round 7 block with `--plan` +turned into `--measure`, a multiline `perf_baseline.py` with `--calibrate` on the +next line, the flag assigned to a shell variable, the flag reached through a +different command name entirely, the flag in a *different* workflow across lines, +and a shell comment that merely names it. + +### And the mutant that found it is now a standing catcher + +Those six cases lived in a scratchpad campaign, which is a memory rather than a +property of the repository. Restore the old conjunction and the live workflow still +says `--plan`: CI goes green and the suite never notices. Proving once that the +vest stops the bullet and then removing the bullet from the tests is a remarkably +comfortable form of rigour. + +`training-scanner-catches-multiline` makes it permanent. The scan itself is now a +pure helper used in both places, so the control exercises the same implementation +the live check runs rather than a copy of it. The mutant is derived from the **real** +Round 7 block in `ci.yml`, located by following the script line through its +continuations, mutated in memory and never written to disk. Nothing in it runs a +clock. + +It also fails closed on the two ways it could pass while testing nothing: if the +Round 7 invocation is inlined so no continuation carries `--plan`, and if the step +disappears altogether. + +A first draft of this control searched the whole file for any `--plan`, and `ci.yml` +has a second one that is a `stale-plan.json` path in an unrelated stage 2 step. The +control passed by mutating that instead, and its success line claimed both belonged +to Round 7. Its own mutation reported MISSED, which is how it was found. The check +is now scoped to the Round 7 block and its message says only what it established. + +## Three binding axes from here on + + policy_implementation_digest c3068ed7fa88… + measurement_harness_digest 562a7f7232da… + training_scope_implementation_digest 614bf9efe6ba… + +The third is new and is computed over every committed `*.py` under +`scripts/training/` with the **same framing** step 4 froze, imported rather than +restated. If the combiner changes after collection starts, the training corpus is +stale, with no discussion about it having been only a small change to an +intersection. + +## The collection, fixed in advance + +Per stratum, one preregistered environment identity covers the whole ladder: rungs +5, 15 and 45, five full runs each, over the complete universe of that stratum. +Fifteen runs per platform, thirty in total. Measuring one rung on one runner and +another rung on a different one would leave `N` as something other than the only +variable that changed. + +Five runs per rung give exactly four observations per cell, from the consecutive +pairs `(r1,r2)`, `(r2,r3)`, `(r3,r4)`, `(r4,r5)` — not five convenient pairs chosen +once the outcome is visible. The universe is the 40 cells the frozen instrument +emits for the six `cal-*` workloads across five rungs, two engines and both regimes; +`training-prereg-universe` computes that from the manifest and the instrument rather +than trusting the number written here. + +Execution order and its seed are fixed now. The seed is `c3068ed7fa880a70`, the +first sixteen hex digits of the policy digest the owner accepted at step 4 before +this document existed, so it is not a number that could have been re-rolled until +the order looked tidy. + +**Exactly one collection.** Not the first satisfactory one of several. It carries a +durable identity from its first run and ends `ADMISSIBLE` or `INVALID` by rules +written here. There is no automatic retry because CI blinked; a repeat after an +abort needs a rule already in this document or a new owner ruling. + +**If either stratum invalidates, the collection yields no admissible step 8 input.** +The surviving stratum's numbers remain durable evidence of what happened, and must +never become a single-stratum fallback model. That would be selection on +survivorship wearing a CI badge. + +## What this does not authorise + +Not the collection, not the fit, not the holdout. The validation pair remains a +separate owner decision, and this document deliberately does not describe it, so +that a training preregistration cannot quietly authorise a fresh validation run. diff --git a/pyproject.toml b/pyproject.toml index 8a9ed88d..d12c0250 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -31,10 +31,21 @@ files = [ "tests/verdict_surface_inventory.py", "tests/shadow_sweep.py", "tests/test_obligation_fact_parity.py", + "scripts/perf_baseline.py", + "scripts/round7/classify.py", + "scripts/round7/elfread.py", + "scripts/round7/preflight.py", + "scripts/round7/schedule.py", + "scripts/round7/runner.py", + "scripts/round7/readout.py", + "scripts/calibration/policy.py", + "scripts/training/scope.py", + "scripts/step7/envcapture.py", "scripts/mutate_campaign.py", "scripts/shadow_compare.py", "scripts/render_checkpoint_status.py", ] -mypy_path = ["tests", "scripts"] +mypy_path = ["tests", "scripts", "scripts/round7", "scripts/calibration", "scripts/training", + "scripts/step7"] explicit_package_bases = true strict = true diff --git a/scripts/calibration/policy.py b/scripts/calibration/policy.py new file mode 100644 index 00000000..ec3fab8b --- /dev/null +++ b/scripts/calibration/policy.py @@ -0,0 +1,546 @@ +#!/usr/bin/env python3 +"""#263-A calibration reproducibility policy — the pure implementation. + +This module is step 2 of the twelve-step sequence in +`docs/notes/p022-263a-calibration-policy-proposal.md`. It is written **before** +any training corpus exists, because an implementation written with the data +already on disk can be nudged, in a hundred defensible small ways, toward the +answer its author has already seen. + +It carries **no constant values and no defaults**. Every design constant is a +required field of one immutable `DesignConstants`, and the empirical constants +are required inputs to the verdict. The code physically cannot hold a number +nobody ratified. + +It is pure: no clock, no files, no network, no randomness, no global state. Same +inputs, same outputs, on any platform. All arithmetic is exact rational, because +every boundary in the policy is decided by a comparison and a binary float would +decide some of them by rounding direction instead of by the rule. + +What lives here, and what the ratified document says about each: + + canonical representation §2.6 rationals as reduced pairs; counts as ints + the four-way verdict §1 reproducible / not-reproducible / + inconclusive / invalid, cell and pair + the symmetric comparison §2.2 bound evaluated at the MIDPOINT + the per-cell rule §2.4 inclusive inner, strict outer + aggregation §2.5 strict precedence, never a count + the empirical fit §3.3 exact vertex enumeration + canonicalisation + selecting N §3.4 per-rung envelopes, diminishing returns + +Nothing here reads a threshold, consults the incumbent constants, or decides +whether any engine is fast enough. Those are D7 questions and §7 keeps them +behind a different freeze. +""" + +from __future__ import annotations + +from collections.abc import Iterable, Mapping, Sequence +from dataclasses import dataclass +from fractions import Fraction +from itertools import pairwise +from math import gcd + +VERDICTS = ("reproducible", "not-reproducible", "inconclusive", "invalid") + + +class PolicyRefused(Exception): + """The policy was handed something it must not silently interpret.""" + + +# --- §2.6 canonical representation ------------------------------------------- + + +def canonical_rational(numerator: object, denominator: object, *, name: str) -> Fraction: + """One rational quantity, from the reduced integer pair that was committed. + + A float is refused rather than converted. The document exists because a + committed decimal is a binary float to one implementation and a rational to + another, and the two then disagree on every boundary case; accepting a float + here would reintroduce exactly that. + """ + def _int(label: str, value: object) -> int: + if isinstance(value, bool) or not isinstance(value, int): + raise PolicyRefused( + f"{name}.{label} is {value!r} ({type(value).__name__}); a rational is " + "committed as a pair of integers, never as a float or a decimal string") + return value + + num, den = _int("numerator", numerator), _int("denominator", denominator) + if den <= 0: + raise PolicyRefused(f"{name} has denominator {den}; the canonical form has a " + "strictly positive denominator, so the pair is unique") + if gcd(abs(num), den) != 1: + raise PolicyRefused( + f"{name} is ({num}, {den}), which is not reduced; the canonical form is " + "unique only when the pair shares no common factor") + return Fraction(num, den) + + +def canonical_count(value: object, *, name: str, minimum: int) -> int: + """One count. A count is an integer, not a rational written as `(n, 1)`. + + Revision 3 required every design constant in reduced-pair form, which left a + reader deciding whether N = 15 meant the integer or the pair. Counts are + integers here and rationals are pairs, and nothing has to be guessed. + """ + if isinstance(value, bool) or not isinstance(value, int): + raise PolicyRefused(f"{name} is {value!r} ({type(value).__name__}); a count is " + "a canonical integer") + if value < minimum: + raise PolicyRefused(f"{name} is {value}; the ratified minimum is {minimum}") + return int(value) + + +def exact_rational(value: object, *, name: str) -> Fraction: + """Every quantity that crosses into the policy's arithmetic, checked at the door. + + `canonical_rational` guards the constants that arrive as committed pairs. + This guards everything else: measured medians, fitted envelopes, reference + durations. Without it the exact domain held at exactly one entry point, and + a float could walk in through a dataclass constructor. + + That is not a typing nicety. `Fraction * float` is a **float** in Python, so + one float anywhere makes the whole downstream computation floating point: + the fitted `R_rel`, the bound, the comparison that decides the verdict. A + module that refused a floating-point LP solver on exactness grounds would + then be deciding its boundaries by rounding direction anyway. + + A float is **refused, never converted**. `Fraction(0.1)` preserves the binary + error with impeccable fidelity, which would be funny rather than useful. An + `int` is refused too: it is exact, but `int / int` is a float in Python, so + admitting it puts a float one ordinary division away. + """ + if not isinstance(value, Fraction): + raise PolicyRefused( + f"{name} is {value!r} ({type(value).__name__}); this policy computes in " + "exact rationals and refuses anything else rather than converting it. " + "Fraction(0.1) would keep the binary error exactly, not remove it") + return value + + +def as_pair(value: object) -> tuple[int, int]: + """The canonical pair for serialisation. Round-trips through `canonical_rational`. + + Guarded like everything else. It cannot corrupt a fit -- it only writes a + number out -- but if the contract is "the public policy surface fails closed + on the exact domain", then a serialiser that dies with `AttributeError` + instead of refusing is a door somebody will later argue was not a door. + """ + return (exact_rational(value, name="as_pair value").numerator, + exact_rational(value, name="as_pair value").denominator) + + +def exact_median(values: Sequence[Fraction], *, name: str) -> Fraction: + """The median in exact arithmetic; an even count averages the two middle values. + + `statistics.median` would return a float for an even-length input and hand a + rounding decision to the comparison that consumes it. + """ + if not values: + raise PolicyRefused(f"{name}: the median of an empty sample is not a number") + ordered = sorted(exact_rational(v, name=f"{name}[{i}]") for i, v in enumerate(values)) + mid = len(ordered) // 2 + if len(ordered) % 2 == 1: + return ordered[mid] + return (ordered[mid - 1] + ordered[mid]) / 2 + + +# --- §3.2 the design set, whole, required, and without defaults --------------- + + +@dataclass(frozen=True) +class DesignConstants: + """All five design constants, together, with no default anywhere. + + Together on purpose. Naming only the constants that appear in a formula + would leave an implementation free to hard-code `r_runs` or `n_ladder` + without contradicting a word of the policy, and those two decide the corpus + cardinality and the `N` selection outright. + + Who consumes what: the fitter uses `q`, `r_runs` and `n_ladder`; the selector + uses `g`; the verdict uses `m`. No field is carried for symmetry. + """ + + q: Fraction + m: Fraction + r_runs: int + n_ladder: tuple[int, ...] + g: Fraction + + def __post_init__(self) -> None: + if not isinstance(self.q, Fraction) or not 0 < self.q < 1: + raise PolicyRefused(f"q is {self.q!r}; the quantile level lies strictly " + "inside (0, 1)") + if not isinstance(self.m, Fraction) or self.m <= 1: + raise PolicyRefused(f"M is {self.m!r}; the outer bound is a strict widening " + "of the inner one, so M > 1") + if not isinstance(self.g, Fraction) or self.g < 0: + raise PolicyRefused(f"G is {self.g!r}; the diminishing-returns margin is " + "non-negative") + canonical_count(self.r_runs, name="R_runs", minimum=2) + if not self.n_ladder: + raise PolicyRefused("the N ladder is empty; a finite ladder must contain at " + "least one rung, and its last element is the mandatory stop") + previous = 0 + for rung in self.n_ladder: + canonical_count(rung, name="an N ladder rung", minimum=1) + if rung <= previous: + raise PolicyRefused( + f"the N ladder {list(self.n_ladder)} is not strictly increasing at " + f"{rung}; an unordered ladder has no well-defined last element and " + "therefore no mandatory stop") + previous = rung + + @classmethod + def from_committed(cls, *, q: tuple[object, object], m: tuple[object, object], + r_runs: object, n_ladder: Sequence[object], + g: tuple[object, object]) -> DesignConstants: + """Build from exactly what was committed: pairs for rationals, ints for counts. + + Every argument is keyword-only and required. There is no default, and + there is no overload that supplies one. + """ + return cls( + q=canonical_rational(q[0], q[1], name="q"), + m=canonical_rational(m[0], m[1], name="M"), + r_runs=canonical_count(r_runs, name="R_runs", minimum=2), + n_ladder=tuple(canonical_count(rung, name="an N ladder rung", minimum=1) + for rung in n_ladder), + g=canonical_rational(g[0], g[1], name="G"), + ) + + @property + def mandatory_stop(self) -> int: + """The ladder's last rung. There is no separate maximum to contradict it.""" + return self.n_ladder[-1] + + def as_committed(self) -> dict[str, object]: + return {"q": as_pair(self.q), "M": as_pair(self.m), "R_runs": self.r_runs, + "N_ladder": list(self.n_ladder), "G": as_pair(self.g)} + + +@dataclass(frozen=True) +class Envelope: + """One rung's fitted inner bound. An empirical output, never a design choice.""" + + n: int + a_abs: Fraction + r_rel: Fraction + + def __post_init__(self) -> None: + canonical_count(self.n, name=f"envelope rung n={self.n!r}", minimum=1) + exact_rational(self.a_abs, name=f"envelope at n={self.n}: A_abs") + exact_rational(self.r_rel, name=f"envelope at n={self.n}: R_rel") + if self.a_abs < 0 or self.r_rel < 0: + raise PolicyRefused( + f"envelope at n={self.n} has A_abs={self.a_abs}, R_rel={self.r_rel}; a " + "bound may not be negative anywhere on the duration range") + + def inner(self, t: object) -> Fraction: + """The inner bound at one duration. `t` is checked, because this is the + one place the envelope meets a caller's number and `Fraction * float` is + a float.""" + return self.a_abs + self.r_rel * exact_rational( + t, name=f"envelope at n={self.n}: duration t") + + def as_committed(self) -> dict[str, object]: + return {"n": self.n, "A_abs": as_pair(self.a_abs), "R_rel": as_pair(self.r_rel)} + + +# --- §1, §2.2, §2.4 the four-way cell verdict -------------------------------- + + +@dataclass(frozen=True) +class CellObservation: + """One cell as the two runs recorded it. `None` means the run did not produce it.""" + + key: str + median_a: Fraction | None + median_b: Fraction | None + exit_a: int | None + exit_b: int | None + valid_a: bool + valid_b: bool + + def __post_init__(self) -> None: + for label, median in (("median_a", self.median_a), ("median_b", self.median_b)): + if median is not None: + exact_rational(median, name=f"{self.key}.{label}") + for label, code in (("exit_a", self.exit_a), ("exit_b", self.exit_b)): + if code is not None and (isinstance(code, bool) or not isinstance(code, int)): + raise PolicyRefused(f"{self.key}.{label} is {code!r}; an exit code is an " + "integer or absent") + for label, flag in (("valid_a", self.valid_a), ("valid_b", self.valid_b)): + if not isinstance(flag, bool): + raise PolicyRefused(f"{self.key}.{label} is {flag!r}; outcome validity is " + "a boolean, and a truthy value is not a boolean") + + +@dataclass(frozen=True) +class CellVerdict: + key: str + verdict: str + why: str + delta: Fraction | None = None + reference_duration: Fraction | None = None + inner: Fraction | None = None + outer: Fraction | None = None + + +def classify_cell(observation: CellObservation, envelope: Envelope, + constants: DesignConstants) -> CellVerdict: + """One cell, four ways. + + The invalid branches come first and they are not failures. An incomparable + cell says nothing about the instrument, and reporting it as a failure to + reproduce would invite fixing it by re-running. + """ + o = observation + if o.median_a is None or o.median_b is None: + return CellVerdict(o.key, "invalid", + "the cell is present in one run and absent from the other, or " + "produced no median; there is nothing to compare") + if not o.valid_a or not o.valid_b: + return CellVerdict(o.key, "invalid", + f"the recorded outcome is not valid in " + f"{'run A' if not o.valid_a else 'run B'}; an invalid cell was " + "never a measurement") + if o.exit_a != o.exit_b: + return CellVerdict(o.key, "invalid", + f"the runs exited {o.exit_a!r} and {o.exit_b!r}; they did not " + "measure the same thing, so their durations are not comparable") + + # §2.2: symmetric in both terms. The bound is evaluated at the MIDPOINT, so + # swapping the runs cannot change the verdict. + delta = abs(o.median_b - o.median_a) + t = (o.median_a + o.median_b) / 2 + inner = envelope.inner(t) + outer = constants.m * inner + + # §2.4: the inner branch is inclusive, the refusing branch is strict. A value + # landing exactly on a boundary is decided by the written rule. + if delta <= inner: + verdict, why = "reproducible", "the change is within the frozen inner bound" + elif delta > outer: + verdict, why = "not-reproducible", "the change is outside the frozen outer bound" + else: + verdict, why = "inconclusive", "the change lies between the inner and outer bounds" + return CellVerdict(o.key, verdict, why, delta, t, inner, outer) + + +def classify_pair(cells: Sequence[CellVerdict], + pair_invalidating: Sequence[str]) -> dict[str, object]: + """The run pair, by strict precedence over its cells. Never by counting. + + There is deliberately no tolerated-failure count. A rule of the form "at most + K cells may fail" introduces a constant whose only function is to decide how + much disagreement to forgive, and it will be adjusted the first time K + 1 + cells fail. + """ + if pair_invalidating: + return {"verdict": "invalid", "why": "; ".join(pair_invalidating), + "counts": _counts(cells), "cells": [c.key for c in cells]} + if not cells: + return {"verdict": "invalid", "why": "the pair covers no cells at all", + "counts": _counts(cells), "cells": []} + + counts = _counts(cells) + for verdict, why in ( + ("invalid", "at least one cell is not comparable, so the pair is not comparable"), + ("not-reproducible", "at least one cell is outside the frozen outer bound"), + ("inconclusive", "at least one cell lies between the inner and outer bounds"), + ): + if counts[verdict]: + named = [c.key for c in cells if c.verdict == verdict] + return {"verdict": verdict, "why": why, "counts": counts, "cells": named} + return {"verdict": "reproducible", "why": "every cell is within the frozen inner bound", + "counts": counts, "cells": []} + + +def _counts(cells: Sequence[CellVerdict]) -> dict[str, int]: + return {v: sum(1 for c in cells if c.verdict == v) for v in VERDICTS} + + +# --- §3.3 the empirical fit --------------------------------------------------- + + +@dataclass(frozen=True) +class Observation: + """One fitting observation: a reference duration and an observed change.""" + + t: Fraction + y: Fraction + + def __post_init__(self) -> None: + exact_rational(self.t, name="observation.t") + exact_rational(self.y, name="observation.y") + + +def observations_from_medians(medians: Sequence[Fraction], constants: DesignConstants, + *, name: str) -> tuple[Observation, ...]: + """`R_runs` medians in recorded order become `R_runs - 1` consecutive-pair rows. + + Consecutive rather than all pairs, because all-pairs observations are not + independent and would silently over-weight cells, and because a second run + following a first is exactly what §9 of the frozen brief tests. + """ + if len(medians) != constants.r_runs: + raise PolicyRefused(f"{name}: {len(medians)} medians for R_runs={constants.r_runs}") + # Defence in depth, and deliberately redundant: `Observation.__post_init__` + # refuses the same floats a line later, so removing this guard changes the + # message and not the outcome. It earns its place by naming WHICH median was + # wrong instead of leaving the caller to work that out from "observation.t", + # and no mutation can distinguish it -- which is stated here rather than + # left looking like an untested line. + for i, median in enumerate(medians): + exact_rational(median, name=f"{name}: median [{i}]") + rows = [] + for earlier, later in pairwise(medians): + rows.append(Observation(t=(earlier + later) / 2, y=abs(later - earlier))) + return tuple(rows) + + +def pinball_loss(observations: Sequence[Observation], q: object, + a_abs: object, r_rel: object) -> Fraction: + """The quantile objective, exactly. rho_q(u) = q*u for u >= 0, (q-1)*u below. + + All three scalars are checked. This is a public function and nothing stops a + caller handing it `q=0.75`; one float here and the objective that decides the + fit is computed in binary floating point, which is precisely what the + enumeration was chosen to avoid. + """ + q = exact_rational(q, name="pinball_loss q") + a_abs = exact_rational(a_abs, name="pinball_loss A_abs") + r_rel = exact_rational(r_rel, name="pinball_loss R_rel") + total = Fraction(0) + for row in observations: + u = row.y - (a_abs + r_rel * row.t) + total += q * u if u >= 0 else (q - 1) * u + return total + + +def _candidates(observations: Sequence[Observation]) -> list[tuple[Fraction, Fraction]]: + """Every vertex an optimum can sit on, per §3.3. + + The objective is piecewise-linear and convex and the feasible region is a + polyhedron, so an optimum is attained where two conditions are active: a + residual condition, `a = 0`, or `r = 0`. A floating-point LP solver would not + be reproducible across platforms; this enumeration is. + """ + out: list[tuple[Fraction, Fraction]] = [] + for i, first in enumerate(observations): + for second in observations[i + 1:]: + if first.t == second.t: + continue + r = (second.y - first.y) / (second.t - first.t) + out.append((first.y - r * first.t, r)) + if first.t != 0: + out.append((Fraction(0), first.y / first.t)) + out.append((first.y, Fraction(0))) + out.append((Fraction(0), Fraction(0))) + return [(a, r) for a, r in out if a >= 0 and r >= 0] + + +def canonical_minimiser(tied: Iterable[tuple[Fraction, Fraction]] + ) -> tuple[Fraction, Fraction]: + """The ratified tie-break, named so it can be tested as a rule in its own right. + + Among all objective minimisers: the smallest `A_abs`; among those, the + smallest `R_rel`. Both keys matter, and the second is only reachable when two + minimisers share an intercept, so it lives here rather than inline where no + corpus would ever exercise it. + + This is **canonicalisation**, not optimisation. It claims no pointwise + dominance over the minimisers it passes over -- tied optimal lines can cross, + and the ratified document records a counterexample. Its only purpose is + identical constants from identical corpus bytes. + """ + checked = [(exact_rational(a, name="minimiser A_abs"), + exact_rational(r, name="minimiser R_rel")) for a, r in tied] + ordered = sorted(checked) + if not ordered: + raise PolicyRefused("no minimiser to canonicalise") + return ordered[0] + + +def fit_envelope(n: int, observations: Sequence[Observation], + constants: DesignConstants) -> Envelope: + """One rung's envelope, by exact vertex enumeration and a stated tie-break. + + **Tie-break, in order:** among all objective minimisers represented by the + enumerated candidate set, the smallest `A_abs`; among those, the smallest + `R_rel`. This is a deterministic *canonicalisation* rule. It does **not** + claim pointwise dominance over every other minimiser -- tied optimal lines + can cross, and the ratified document records a counterexample. Its purpose is + identical constants from identical corpus bytes, and that is the whole of it. + """ + if not observations: + raise PolicyRefused(f"n={n}: no observations to fit") + for row in observations: + if row.y < 0: + raise PolicyRefused(f"n={n}: an observation has y={row.y}; y is an absolute " + "difference and cannot be negative") + if len({row.t for row in observations}) < 2: + raise PolicyRefused( + f"n={n}: the corpus has fewer than two distinct reference durations, so a " + "two-parameter model is not identifiable; refusing rather than guessing") + + candidates = _candidates(observations) + if not candidates: + raise PolicyRefused(f"n={n}: no feasible candidate survives A_abs >= 0, R_rel >= 0") + + scored = [(pinball_loss(observations, constants.q, a, r), a, r) for a, r in candidates] + best = min(loss for loss, _, _ in scored) + a_abs, r_rel = canonical_minimiser({(a, r) for loss, a, r in scored if loss == best}) + return Envelope(n=n, a_abs=a_abs, r_rel=r_rel) + + +# --- §3.4 selecting N, with N as a stratum ------------------------------------ + + +def envelope_width(envelope: Envelope, reference_durations: Sequence[Fraction]) -> Fraction: + """W for one rung: the envelope summed over the named universe's cells.""" + if not reference_durations: + raise PolicyRefused(f"n={envelope.n}: the workload universe is empty, so its " + "envelope width is not defined") + checked = [exact_rational(t, name=f"n={envelope.n}: reference duration [{i}]") + for i, t in enumerate(reference_durations)] + return sum((envelope.inner(t) for t in checked), Fraction(0)) + + +def select_n(envelopes: Mapping[int, Envelope], + reference_durations: Mapping[int, Sequence[Fraction]], + constants: DesignConstants) -> dict[str, object]: + """The smallest rung within `G` of the best width the ladder can achieve. + + Computed from training evidence alone and never revisited afterwards. The + forbidden rule -- "the smallest N at which the pair reproduces" -- turns the + stop rule into a starting gun, so `N` is fixed before the validation pair + exists and is not adjusted once it does. + + Always defined: the rung achieving the minimum satisfies the inequality for + any G >= 0, so there is no undefined branch. + """ + missing = [n for n in constants.n_ladder if n not in envelopes] + if missing: + raise PolicyRefused(f"no envelope for ladder rungs {missing}; every rung is fitted " + "or the selection is over a ladder that was not measured") + widths = {} + for n in constants.n_ladder: + if n not in reference_durations: + raise PolicyRefused(f"no reference durations for rung n={n}") + widths[n] = envelope_width(envelopes[n], reference_durations[n]) + + best = min(widths.values()) + limit = (1 + constants.g) * best + for n in constants.n_ladder: # ascending: smallest that qualifies + if widths[n] <= limit: + return {"selected_n": n, + "widths": {k: as_pair(v) for k, v in widths.items()}, + "best_width": as_pair(best), "limit": as_pair(limit), + "why": f"n={n} is the smallest rung whose width is within " + f"(1 + G) of the ladder's best"} + raise PolicyRefused( # unreachable for G >= 0 + "no rung is within (1 + G) of the best width, which is impossible for G >= 0 " + "and means the widths or the margin were not what this function was handed") diff --git a/scripts/perf_baseline.py b/scripts/perf_baseline.py new file mode 100644 index 00000000..e53a0425 --- /dev/null +++ b/scripts/perf_baseline.py @@ -0,0 +1,2439 @@ +#!/usr/bin/env python3 +"""#263-A — the P-022 performance measurement INSTRUMENT (calibration only). + +What this is, and just as importantly what it is not. This module produces the +numbers for #263's baselines; it does not decide anything with them. #263-A +freezes *how* a measurement is taken. Thresholds, the repetition count N, and +the Rust-vs-Python comparison statistic are D7's, frozen separately and before +the decisive run. Nothing here may choose them, and nothing here may be used to +choose them. + +THE FIREWALL, which is the whole point of the module's shape +------------------------------------------------------------ +Workloads come in two populations, declared in +``docs/evidence/p022-263a-workloads.json``: + + DECISIVE the G3 cutover subset. These feed D7. + CALIBRATION generated here, deterministically, to validate the instrument. + +Before the D7 freeze, a decisive workload may be enumerated, hashed, fetched, +availability-checked, and exercised by NON-TIMED structural smoke — and nothing +else. It may not be timed, its memory may not be sampled, and no engine +comparison over it may be produced *in any form, saved or not*. "We did not +write the delta down" is accounting-clean and epistemically worthless: whoever +watched the two numbers has already peeked, and every threshold they choose +afterwards is a rationalisation with a timestamp. + +So the prohibition is structural rather than clerical. There is exactly one +function in this module that starts a clock, and it refuses a decisive workload +unless the identity gate is ARMED — which requires a valid D7 attestation, which +does not exist yet and cannot be forged into existence by editing this file. + +TWO IDENTITY DOMAINS, deliberately not merged +--------------------------------------------- +* The C1/C2 GATE domain — reference identity, harness identity, workload + manifest identity, D7 payload validity. Dormant here. It exists now, unarmed, + because D7's C1 will freeze the harness digest: a gate bolted on after that + freeze makes this a different instrument and forces re-calibration and + re-freeze. Arming it is DATA ONLY (a JSON attestation), never a source patch — + if arming would change the harness digest, the design is wrong. +* The SESSION identity — the candidate binary's sha256, byte length and + provenance, frozen when the session starts. The candidate is the thing under + test, so it is emphatically NOT part of instrument identity. Drift refuses the + remainder of the session: half the cells on binary A and half on binary B is + not a measurement, it is two measurements wearing one hat. + +Both verifications run to completion, and pass, BEFORE any clock starts, and +the notary's own cost (the digests) falls outside every measured interval. A +gate that bakes its own cost into the startup benchmark is a defect wearing a +safeguard's coat. + +WHAT IS AND IS NOT SEPARATELY OBSERVABLE +---------------------------------------- +Neither engine exposes per-phase timing through its production surface, and +#263-A is not authorized to add production instrumentation. So phases are +measured through a LADDER of real production invocations, each recorded as the +composed interval it actually is, with the phases it contains named. Where a +phase cannot be isolated, it is recorded as ``composed`` or ``unavailable`` +rather than invented — #263 asks for unavailable stages to be marked, not +imputed. The raw per-iteration data is retained so D7 can decompose differently +if it wants to; this module never presents a derived phase as if it had been +measured directly. + +Run: + python scripts/perf_baseline.py --selftest instrument checks, no timing + python scripts/perf_baseline.py --calibrate CALIBRATION_ONLY measurement + python scripts/perf_baseline.py --smoke-decisive non-timed structural smoke +""" + +from __future__ import annotations + +import argparse +import ctypes +import hashlib +import json +import os +import platform +import random +import re +import statistics +import subprocess +import sys +import tempfile +import time +from collections.abc import Sequence +from dataclasses import dataclass, field +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +MANIFEST = ROOT / "docs/evidence/p022-263a-workloads.json" +# D7 §6: two objects in two commits. C1 is the payload; C2 is the detached +# attestation that must live in a strictly later commit. +D7_PAYLOAD = ROOT / "docs/evidence/p022-263a-d7-payload.json" +D7_ATTESTATION = ROOT / "docs/evidence/p022-263a-d7-attestation.json" +HARNESS_VERSION = 1 + +CALIBRATION_ONLY = "CALIBRATION_ONLY" + +# Calibration knobs, named so a control can read them. +# +# Repetitions is the sanctioned sizing knob: an owner-bounded escalation may +# raise it for a report of record. WARMUP IS NOT. It was changed from 2 to 3 +# alongside a repetitions escalation that had been authorised on its own, which +# turned one permitted knob into two turned after seeing which runs went red. +# A committed calibration must use this default; changing it is a deliberate +# policy edit in one place, not a flag someone passes. +DEFAULT_CALIBRATION_REPETITIONS = 5 +DEFAULT_WARMUP_DISCARDS = 2 + + +class InstrumentError(RuntimeError): + """The instrument refuses to proceed. Always fail-closed, never a warning.""" + + +class FirewallBreach(InstrumentError): + """An attempt to measure a decisive workload before the D7 freeze.""" + + +# --- digests --------------------------------------------------------------- + + +def sha256_file(path: Path) -> tuple[str, int]: + h = hashlib.sha256() + n = 0 + with open(path, "rb") as f: + while chunk := f.read(1 << 20): + h.update(chunk) + n += len(chunk) + return h.hexdigest(), n + + +def sha256_bytes(data: bytes) -> str: + return hashlib.sha256(data).hexdigest() + + +_CRLF = b"\r\n" +_LF = b"\n" + + +def normalized_text(data: bytes) -> bytes: + """Line endings normalized, so identity is content and not checkout policy. + + One function, because every identity D7 freezes has to agree about what the + same content means. Round 3 fixed the harness digest and left + ``load_manifest`` hashing raw bytes two hundred lines away, which is the + same defect with a different variable name. + """ + return data.replace(_CRLF, _LF) + + +def sha256_text_file(path: Path) -> tuple[str, int]: + """Hash a TEXT file by its content, with line endings normalized. + + The harness digest must name the INSTRUMENT, not the checkout it came from. + A Windows checkout with ``core.autocrlf=true`` stores the same source with + CRLF, so a raw-byte digest gives one instrument two identities — and D7's C1 + freezes that value, so a freeze would arm on one platform and refuse on the + other while #263-B has to run on both. Caught by CI: the same tree hashed + af32f04ddbad on Linux and 51ef2ca2422a on Windows. + + This repository already knows the defect class — ``.gitattributes`` pins + ``docs/evidence/*.json`` to LF because campaign definition hashes hit it + first — but an attribute only governs files git checks out under it. A file + already in a working tree, a zip download, or a contributor whose clone + predates the rule all still differ. An identity that D7 will freeze should + depend on content, so it is normalized here rather than delegated to a + checkout setting. + + Raw ``sha256_file`` stays raw: the candidate binary is bytes, and + normalizing a binary would be a different kind of wrong. + """ + data = normalized_text(path.read_bytes()) + return sha256_bytes(data), len(data) + + +SELF = Path(__file__).resolve() + +# The files whose CONTENT is the instrument. The manifest is in here on +# purpose: it means proving the harness digest at a commit also proves the +# workload manifest at that commit, so there is no second anchor check to write +# and no second anchor check to get wrong. +INSTRUMENT_SOURCES: tuple[Path, ...] = (SELF, MANIFEST) + + +def _instrument_rel(path: Path) -> str: + """Repository-relative path, so the same source can be read out of any + checkout of this repository rather than only out of this one.""" + return path.relative_to(ROOT).as_posix() + + +def _harness_digest_from(parts: Sequence[tuple[str, bytes]]) -> str: + """The digest formula, written ONCE. + + ``harness_digest`` reads the working tree and ``harness_digest_at`` reads + git blobs at a commit. The D7 anchor proof compares one against the other, + so if these were two implementations of "the same" formula the proof would + be comparing two functions and calling their agreement meaningful. + """ + lines = [f"{name}:{sha256_bytes(normalized_text(data))}" for name, data in parts] + return sha256_bytes("\n".join(lines).encode("utf-8")) + + +def harness_digest() -> str: + """The instrument's own identity: this file plus the frozen manifest. + + D7's C1 freezes this value. It deliberately does NOT include the candidate + binary or any attestation: the candidate is the thing under test, and an + attestation that changed the digest it attests to could never be written + down. + """ + return _harness_digest_from([(p.name, p.read_bytes()) for p in INSTRUMENT_SOURCES]) + + +def harness_digest_at(repo: Path, commit: str) -> str | None: + """The same identity, computed from the instrument as it existed AT a commit. + + This is what makes the D7 anchor a provenance claim rather than a position + assertion: C1 names the accepted #263-A commit S, and the gate proves that + the instrument at S really is the instrument whose digest C1 froze. ``None`` + means S does not contain the instrument at all, which is a refusal, not a + pass. + """ + parts: list[tuple[str, bytes]] = [] + for src in INSTRUMENT_SOURCES: + rc, data = _git_bytes(repo, "show", f"{commit}:{_instrument_rel(src)}") + if rc != 0: + return None + parts.append((src.name, data)) + return _harness_digest_from(parts) + + +# --- identity: the D7 C1/C2 gate (dormant) --------------------------------- + + +# D7 §6 defines TWO GIT COMMITS, not two sections of one file. +# +# C1 the immutable payload commit — thresholds/rules/rollups, the Python +# reference sha, the #263-A tree sha, harness digest and version, the +# workload manifest digest, and the owner's ratification. +# C2 a detached attestation in a DESCENDANT commit — the payload's commit +# sha, its blob sha, the sha256 of its EXACT bytes, the instrument / +# reference / workload bindings, and the ratification binding. +# +# The previous implementation used the same two letters for something else: C1 +# and C2 were sections INSIDE one payload, with "c2" holding threshold values. +# The word had quietly changed profession, and an equivalent-looking scheme is +# not the frozen scheme. What follows implements §6 as quoted, including the +# parts the old design had no equivalent of at all: payload_blob_sha, the +# exact-byte hash rather than a canonical-JSON one, and proof that C2's commit +# is a descendant of C1's. +D7_PAYLOAD_KIND = "own.net/p022/d7-payload" # C1 +D7_ATTESTATION_KIND = "own.net/p022/d7-attestation" # C2 + +D7_SCHEMA = 1 + +# C1 content. +# +# The gate must never READ a threshold: a #263-A artifact that quoted one would +# leak the number this module exists to keep out. It does not follow that the +# gate may ignore whether a preregistration is THERE. The previous version +# checked three key names for presence, and its own fixture armed the gate with +# +# thresholds = "" +# rules = "" +# rollups = "" +# +# — two immaculate git commits, three celebratory strings, and the decisive +# firewall opens. Structure is verified; values are never read, compared, +# ordered or echoed. +D7_PAYLOAD_PROTOCOL_KEYS = ("cells", "rollups") + +# Per D7: every (phase x workload-id x platform x regime) cell carries a +# budget/regression bound, a pass/fail rule, an inconclusive band, a repetition +# ladder with its stopping rule, a comparison statistic, and RSS/allocation +# treatment — or says in so many words that it does not apply. +D7_CELL_DIMENSIONS = ("phase", "workload_id", "platform", "regime") +D7_CELL_RULE_KEYS = ("bound", "pass_fail_rule", "inconclusive_band", "repetition_ladder", + "comparison_statistic", "rss_policy", "allocation_policy") +D7_LADDER_KEYS = ("initial_n", "escalation_stages", "transition_predicates", "max_n", + "terminal_outcome") +D7_CELL_NA_KEY = "not_applicable" + +# Preregistered roll-ups, cell -> phase -> overall. +D7_ROLLUP_LEVELS = ("workload_class", "phase", "overall_g3") + +# --- D7's measurement vocabulary, which is NOT the attribution taxonomy ---- +# +# PHASES answers "what did this timed interval CONTAIN", so an instrument rung +# can be attributed honestly. D7_PHASES names the G3 cutover METRICS the owner +# preregisters a rule for. The two overlap heavily, which is exactly why using +# one as the other went unnoticed: building the universe from `sorted(PHASES)` +# demanded a preregistered rule for `cli-argv-parse` on every workload, platform +# and regime, while the user-visible end-to-end C# run — one of the metrics +# carrying the most weight in the G3 verdict — was not in the universe at all. +# +# The fixture said so out loud and was not listened to: it auto-marked all 48 +# `frontend-extraction` cells not-applicable. The code already knew they were +# not D7's business and required them anyway. +# +# NAMES ARE PROVISIONAL. This set comes from the owner's review and the live +# #262 performance-gate list, not from the frozen file, and the mapping between +# these ids and the frozen #262/#263-A vocabulary needs one explicit +# ratification. That is the whole lesson of this defect: an implementation +# label became a normative contract because nobody wrote down which it was. +D7_PHASES = ( + "process-startup-core", + "process-startup-launcher", + "ownir-parse", + "bridge-lowering", + "analysis", + "render-human", + "render-sarif", + "end-to-end-csharp", +) + +# Real parts of real intervals that are NOT G3 metrics. Kept as DATA with the +# reason attached, so an exclusion is a reviewable decision rather than +# something that quietly fell off a list. +D7_NON_METRIC_PHASES = { + "cli-argv-parse": + "argument handling present in every real core invocation; an attribution " + "component, never a gate of its own", + "cli-usage-refusal": + "the driver banner the floor rung writes; it exists to make that rung a " + "BOUND on startup, not a metric", + "ownir-door-refusal": + "the strict door's refusal message; a correctness surface, not a " + "performance gate", + "frontend-extraction": + "diagnostic: recorded, and NOT D7-gated unless the owner separately " + "ratifies it", +} + +# A D7 metric with no single attribution phase: the user-visible whole is the +# launcher-e2e rung's ENTIRE interval, which PHASES can only describe as parts. +D7_METRICS_WITHOUT_PHASE = { + "end-to-end-csharp": + "the launcher-e2e rung end to end — launcher startup, extraction, core " + "startup, parse, analysis and render as one user-visible number", +} + + +def d7_vocabulary_problems() -> list[str]: + """The two vocabularies must stay explicitly related, forever. + + Checked at selftest as well as by a control, because the failure mode is + drift: someone adds a phase to PHASES and the D7 universe silently grows or + silently does not. Every attribution phase must be either promoted to a D7 + metric or explicitly excluded with a reason. Neither is a default. + """ + problems: list[str] = [] + for name in D7_PHASES: + if name in D7_NON_METRIC_PHASES: + problems.append(f"{name} is both a D7 metric and excluded from D7") + if name not in PHASES and name not in D7_METRICS_WITHOUT_PHASE: + problems.append( + f"D7 metric {name} is neither an attribution phase nor declared as a metric " + "that has no single phase") + for name in D7_NON_METRIC_PHASES: + if name not in PHASES: + problems.append(f"{name} is excluded from D7 but is not an attribution phase either") + for name in D7_METRICS_WITHOUT_PHASE: + if name not in D7_PHASES: + problems.append(f"{name} is declared a metric without a phase but is not a D7 metric") + unclassified = [p for p in PHASES + if p not in D7_PHASES and p not in D7_NON_METRIC_PHASES] + if unclassified: + problems.append( + "attribution phases neither promoted to a D7 metric nor explicitly excluded: " + + ", ".join(sorted(unclassified))) + return problems + + +# D7's own vocabulary for the two axes the running process does not enumerate. +# The expected universe covers BOTH platforms wherever the gate runs, because +# #263-B runs on both and C1 freezes decisions for both; a linux gate that only +# demanded linux cells would let half the experiment through unfrozen. +D7_PLATFORMS = ("linux", "windows") +D7_REGIMES = ("process-cold", "warm") + + +def canonical_workload_id(w: Workload) -> str: + """An alias resolves to the id it aliases. + + ``large-solution-control`` and ``oss-ShareX.sln`` are the same path at the + same pin; the manifest declares the alias precisely so the pair is never + counted twice in a denominator. A completeness check that treated them as + two cells would turn that safeguard into a machine for giving ShareX two + votes. + """ + alias = w.spec.get("alias_of") + return str(alias) if alias else w.id + + +def expected_d7_cells() -> tuple[tuple[str, str, str, str], ...]: + """Every (D7 metric, workload_id, platform, regime) D7 has to decide about. + + The first axis is ``D7_PHASES``, the G3 cutover metrics — NOT ``PHASES``, + which is the attribution taxonomy for what a timed interval contains. An + earlier revision used the latter, and so required a preregistered rule for + argv parsing while omitting the end-to-end C# metric entirely. + + Enumeration only — ids and taxonomy, never content and never a clock. The + brief permits enumerating, hashing and availability-checking decisive + workloads before the freeze and forbids only performance exposure, which is + what makes this knowable now. It has to be knowable now: if the decisive + population were not known before D7, D7 could not be written. + + Applicability is expressed by the payload, not here. Every cell in this + universe must carry either a complete rule or an explicit `not_applicable` + with a reason, so the gate proves the owner DECIDED about each one without + ever deciding anything itself. + """ + workloads, _ = load_manifest() + ids = sorted({canonical_workload_id(w) for w in workloads if w.decisive}) + return tuple( + (phase, wid, platform, regime) + for phase in sorted(D7_PHASES) + for wid in ids + for platform in D7_PLATFORMS + for regime in D7_REGIMES + ) + +# The accepted #263-A source commit S. DECLARED by C1 and PROVED by content — +# it is deliberately not in D7_PAYLOAD_BINDING_KEYS, because those are compared +# against what this process observes and S is precisely the thing that must NOT +# equal the current position. +D7_PAYLOAD_ANCHOR = "instrument_anchor_commit" + +D7_PAYLOAD_BINDING_KEYS = ( + "python_reference_commit", "python_reference_tree", + "harness_digest", "harness_version", "workload_manifest_sha256", +) +D7_PAYLOAD_KEYS = ("kind", "schema", *D7_PAYLOAD_PROTOCOL_KEYS, D7_PAYLOAD_ANCHOR, + *D7_PAYLOAD_BINDING_KEYS, "ratification") +D7_RATIFICATION_KEYS = ("owner", "ratified_at", "signature") + +# C2 content. +D7_ATTESTATION_KEYS = ("kind", "schema", "payload_path", "payload_commit_sha", + "payload_blob_sha", "payload_sha256", "bindings", + "ratification_binding") + +_HEX40 = re.compile(r"\A[0-9a-f]{40}\Z") +_HEX64 = re.compile(r"\A[0-9a-f]{64}\Z") + + +def _as_obj(value: object) -> dict[str, object]: + """Narrow a JSON value to an object, or to an empty one. + + Every reader here parses JSON, so mypy sees `object` and the code was + littered with `x.get(k) or {}` plus a `type: ignore` that had drifted to the + wrong error code. This says the same thing once, and says it to the type + checker as well as the reader. + + A non-object where an object belongs becomes empty rather than raising, so + the caller's own completeness check refuses it. That is the fail-closed + direction: a malformed report should be REFUSED by the rule that reads it, + not crash with an AttributeError three frames away from the cause. + """ + return value if isinstance(value, dict) else {} + + +def _as_list(value: object) -> list[object]: + """Narrow a JSON value to an array, or to an empty one. See ``_as_obj``.""" + return list(value) if isinstance(value, list) else [] + + +def _as_int(value: object, default: int = 0) -> int: + """Narrow a JSON value to an int. `bool` is rejected: it is not a count.""" + if isinstance(value, bool): + return default + return value if isinstance(value, int) else default + + +def _as_float(value: object, default: float = 0.0) -> float: + """Narrow a JSON value to a float. See ``_as_obj``.""" + if isinstance(value, bool): + return default + return float(value) if isinstance(value, (int, float)) else default + + +def _present(value: object) -> bool: + """Is this field THERE — without asking what it says. + + A blank string, an empty list and an empty object are all structurally + absent however confidently they are typed. Nothing here compares, orders or + records a value, so a threshold cannot leak through this function. + + A BOOLEAN is rejected outright. `true` is a yes/no, never a preregistered + decision, and the previous version returned True for it — so + ``not_applicable: true`` sailed through a check whose whole purpose was to + demand a stated reason, and ``not_applicable: false`` did too. `bool` is + checked before `int` because in Python a bool IS an int. + """ + if isinstance(value, bool): + return False + if isinstance(value, str): + return value.strip() != "" + if isinstance(value, (list, tuple, dict)): + return len(value) > 0 + return value is not None + + +def _d7_protocol_problems(payload: dict[str, object]) -> list[str]: + """Does C1 carry a preregistration D7 would recognise? + + Two questions, and the second is the one that was missing. Is each cell + given well formed — and are ALL the cells given? A payload with one + immaculate cell and three roll-up strings satisfied the first and said + nothing about 527 others. + + Every problem names the field or cell it is about, so a control can match a + damaged freeze against the check that owns it. One broad "malformed + protocol" refusal would let a dozen missing checks hide behind a single + passing case. + """ + problems: list[str] = [] + + cells = payload.get("cells") + if not isinstance(cells, dict) or not cells: + problems.append( + "cells must be a non-empty object keyed by cell id, one entry per " + "(" + " x ".join(D7_CELL_DIMENSIONS) + ")") + return problems + + workloads, _ = load_manifest() + canonical = {w.id: canonical_workload_id(w) for w in workloads} + identities: dict[tuple[str, str, str, str], list[str]] = {} + dimensions_sound = True + + for cid, spec in sorted(cells.items(), key=lambda kv: str(kv[0])): + where = f"cell {str(cid)!r}" + if not isinstance(spec, dict): + problems.append(f"{where} is not an object") + dimensions_sound = False + continue + + dims = spec.get("dimensions") + if not isinstance(dims, dict): + problems.append(f"{where} declares no dimensions object") + dimensions_sound = False + else: + absent = [d for d in D7_CELL_DIMENSIONS if not _present(dims.get(d))] + if absent: + problems.append(f"{where} is missing dimension(s): " + ", ".join(absent)) + dimensions_sound = False + else: + wid = str(dims["workload_id"]) + identity = (str(dims["phase"]), canonical.get(wid, wid), + str(dims["platform"]), str(dims["regime"])) + identities.setdefault(identity, []).append(str(cid)) + + has_rule = [k for k in D7_CELL_RULE_KEYS if k in spec] + if D7_CELL_NA_KEY in spec: + reason = spec.get(D7_CELL_NA_KEY) + if not isinstance(reason, str) or not reason.strip(): + # `true` is a yes/no. An explicit N/A is a preregistered + # DECISION and has to say why, or "not applicable" is just a + # shorter way of writing "no rule" that reads like a rule. + problems.append( + f"{where} is marked {D7_CELL_NA_KEY} with no stated reason: it must be a " + "non-empty string, not a boolean") + if has_rule: + problems.append( + f"{where} is both {D7_CELL_NA_KEY} and carries a rule (" + + ", ".join(sorted(has_rule)) + "): a cell cannot be applicable and " + "inapplicable at once") + continue + + absent = [k for k in D7_CELL_RULE_KEYS if not _present(spec.get(k))] + if absent: + problems.append( + f"{where} carries neither a complete rule nor an explicit " + f"{D7_CELL_NA_KEY} — missing: " + ", ".join(absent)) + + ladder = spec.get("repetition_ladder") + if _present(ladder): + if not isinstance(ladder, dict): + problems.append(f"{where} repetition_ladder is not an object") + else: + gaps = [k for k in D7_LADDER_KEYS if not _present(ladder.get(k))] + if gaps: + problems.append( + f"{where} repetition_ladder is missing: " + ", ".join(gaps)) + + # Completeness. Only meaningful once every cell has an identity to compare; + # otherwise a malformed dimension would be reported twice, once as itself + # and once as a hole it did not make. + if dimensions_sound: + expected = set(expected_d7_cells()) + for identity, names in sorted(identities.items()): + if len(names) > 1: + problems.append( + "cells " + ", ".join(repr(n) for n in names) + " name the same D7 cell twice (" + + " x ".join(identity) + "); an alias does not earn a second vote") + unknown = sorted(i for i in identities if i not in expected) + if unknown: + problems.append( + f"{len(unknown)} of {len(identities)} cells are not a cell D7 covers, first: " + + " x ".join(unknown[0])) + missing = sorted(expected - set(identities)) + if missing: + problems.append( + f"the payload does not decide every D7 cell: {len(missing)} of {len(expected)} " + "are absent, first: " + " x ".join(missing[0]) + + ". Every cell needs a rule or an explicit " + D7_CELL_NA_KEY) + + rollups = payload.get("rollups") + if not isinstance(rollups, dict): + problems.append("rollups must be an object carrying the preregistered levels " + + ", ".join(D7_ROLLUP_LEVELS)) + else: + absent = [lv for lv in D7_ROLLUP_LEVELS if not _present(rollups.get(lv))] + if absent: + problems.append("rollups is missing preregistered level(s): " + ", ".join(absent)) + return problems + + +def _git_in(repo: Path, *args: str) -> tuple[int, str]: + """Run git inside a named repository. Always outside a measured interval. + + Counted by the notary control: obligation (c) is that identity work never + bills the benchmark for its own cost, and the only way to know that is to + count the calls while a clock is running. + """ + r = subprocess.run(["git", *args], capture_output=True, cwd=str(repo), check=False) + return r.returncode, r.stdout.decode("utf-8", "replace").strip() + + +def _git_bytes(repo: Path, *args: str) -> tuple[int, bytes]: + """Like ``_git_in`` but returns RAW stdout. + + ``git show :`` produces file content, and content must not be + decoded-and-stripped on its way to a hash: stripping a trailing newline + would make a file hash differently depending on which reader found it. + """ + r = subprocess.run(["git", *args], capture_output=True, cwd=str(repo), check=False) + return r.returncode, r.stdout + + +def _committed_blob_matches(repo: Path, rev: str, path_in_repo: str, + on_disk: Path) -> tuple[bool, str]: + """Is this file, as git sees it, the blob committed at ``rev``:``path``? + + ``git hash-object`` applies the same filters git would, so a CRLF checkout + on Windows compares equal to an LF blob instead of reading as tampering. + """ + rc, committed = _git_in(repo, "rev-parse", "--verify", "--quiet", f"{rev}:{path_in_repo}") + if rc != 0 or not committed: + return False, f"nothing is committed at {path_in_repo!r} in {rev[:12]}" + rc, ondisk = _git_in(repo, "hash-object", "--", str(on_disk)) + if rc != 0 or not ondisk: + return False, f"git could not hash {on_disk.name} on disk" + if ondisk != committed: + return False, (f"{on_disk.name} on disk ({ondisk[:12]}) is not the blob committed at " + f"{rev[:12]} ({committed[:12]}): it was modified after it was frozen") + return True, committed + + +@dataclass(frozen=True) +class IdentityGate: + """The D7 C1/C2 domain. Present, verified, and — until D7 — unarmed. + + Armed state requires BOTH commits of §6 and every check in ``load``. There + is no flag, no environment variable and no code path that arms it otherwise, + because a gate that can be waved through is a comment. + + What arming costs: an immutable payload commit carrying the frozen protocol + and every binding; then, in a strictly LATER commit, a detached attestation + naming that commit, that blob, and the sha256 of the payload's exact bytes. + Two commits in order, both reviewable, neither able to be written after the + fact without leaving the other inconsistent. + + What this does NOT prove: git object identity is not a signature. Anyone + with write access could author both commits. The ratification records who + and when, and records plainly when it is unsigned. + + Arming stays DATA-ONLY — two JSON files and two commits — so the harness + digest D7 freezes does not move when the gate arms. + """ + + armed: bool + reason: str + pinned: dict[str, str] = field(default_factory=dict) + observed: dict[str, str] = field(default_factory=dict) + + @staticmethod + def observe(manifest_digest: str, root: Path = ROOT) -> dict[str, str]: + """What this process can see about itself, for C1 to be checked against. + + These are the values C1 must EQUAL, so every one of them has to be + stable across the freeze that writes C1 and C2. ``instrument_tree_sha = + git rev-parse HEAD`` used to be in here and was none of those things: + the real lifecycle is + + S (accepted #263-A tree) -> C1 -> C2 -> #263-B runs + + so by the time #263-B runs, HEAD is at least C2 and can never equal S. + A freeze that satisfied this check would have to name a future + content-addressed commit sha inside the commit that determines it, and + git is not moved by human ingenuity. The instrument anchor is now + DECLARED by C1 and proved by content — see ``harness_digest_at`` — and + the current position is not asserted at all. + """ + return { + "python_reference_commit": python_reference_commit(root), + "python_reference_tree": python_reference_tree(root), + "harness_digest": harness_digest(), + "harness_version": str(HARNESS_VERSION), + "workload_manifest_sha256": manifest_digest, + } + + @staticmethod + def requirements() -> list[str]: + """What a D7 freeze must satisfy, recorded in the report so the evidence + describes its own gate instead of asking a reader to trust this file.""" + return [ + f"C1: a payload at {D7_PAYLOAD.name} declaring kind={D7_PAYLOAD_KIND!r}, carrying " + + ", ".join(D7_PAYLOAD_KEYS), + "C1 carries a STRUCTURALLY COMPLETE preregistration: " + ", ".join( + D7_PAYLOAD_PROTOCOL_KEYS) + "; each cell declares " + + ", ".join(D7_CELL_DIMENSIONS) + " and either " + ", ".join(D7_CELL_RULE_KEYS) + + " (the ladder carrying " + ", ".join(D7_LADDER_KEYS) + ") or an explicit " + + D7_CELL_NA_KEY + " naming a reason in words; roll-ups carry " + + ", ".join(D7_ROLLUP_LEVELS) + ". Values are never read", + f"C1 decides EVERY one of the {len(expected_d7_cells())} cells D7 covers — " + + " x ".join(D7_CELL_DIMENSIONS) + " over the frozen decisive manifest with " + "aliases resolved — with no cell missing, unknown, or named twice", + f"C1 declares {D7_PAYLOAD_ANCHOR} S, and the instrument AT S hashes to the " + "harness_digest C1 froze; S is an ancestor of C1. The CURRENT position is never " + "required to equal S, because by #263-B it cannot be", + "C1's bindings equal what this process observes: " + + ", ".join(D7_PAYLOAD_BINDING_KEYS), + f"C2: a detached attestation at {D7_ATTESTATION.name} declaring " + f"kind={D7_ATTESTATION_KIND!r}, carrying " + ", ".join(D7_ATTESTATION_KEYS), + "C2's payload_sha256 equals the sha256 of the payload's EXACT BYTES", + "C2's payload_blob_sha equals the git blob sha of the payload at payload_commit_sha, " + "and the payload's working-tree bytes are that blob", + "C2's own commit is a strict DESCENDANT of payload_commit_sha", + "C2's bindings and ratification_binding equal C1's", + "both objects are committed and unmodified in the working tree", + ] + + @staticmethod + def load(manifest_digest: str, reference_sha: str | None = None) -> IdentityGate: + # Observe the repository the freeze actually lives in. When those are + # two different repositories the gate would verify one and describe the + # other, which is how the fixtures used to pass while production could + # never have armed. + freeze_root = _repo_root(D7_PAYLOAD) + root = freeze_root or ROOT + observed = IdentityGate.observe(manifest_digest, root) + if not D7_PAYLOAD.is_file(): + return IdentityGate( + armed=False, + reason="no D7 payload on disk: the freeze has not happened, so the gate is " + "dormant by design and every decisive measurement is refused", + observed=observed) + + raw_payload = D7_PAYLOAD.read_bytes() + payload = _read_json_or_refuse(D7_PAYLOAD, "D7 payload") + + # --- C1 shape ----------------------------------------------------- + if payload.get("kind") != D7_PAYLOAD_KIND or payload.get("schema") != D7_SCHEMA: + raise InstrumentError( + f"{D7_PAYLOAD.name} does not declare itself a D7 payload " + f"(kind={payload.get('kind')!r}, schema={payload.get('schema')!r}). Matching " + "identity values are not a freeze: they are values anyone with this repository " + "can compute.") + missing = [k for k in D7_PAYLOAD_KEYS if k not in payload] + if missing: + raise InstrumentError("the D7 payload is incomplete, missing: " + ", ".join(missing)) + rat = payload["ratification"] + if not isinstance(rat, dict) or [k for k in D7_RATIFICATION_KEYS if k not in rat]: + raise InstrumentError( + "the D7 payload carries no complete ratification (needs " + + ", ".join(D7_RATIFICATION_KEYS) + "): an unratified freeze is a draft") + if rat["signature"] != "none": + raise InstrumentError( + 'ratification.signature must be exactly "none" for this version of the ' + "instrument. Signed ratification is not part of the accepted contract: it would " + "need a real signing key and a control exercising ACCEPTANCE, neither of which " + "exists here, and a signature check nothing can test is not a check.") + + # --- C1 bindings against observation ------------------------------ + mismatched = [k for k in D7_PAYLOAD_BINDING_KEYS if str(payload[k]) != observed[k]] + if mismatched: + raise InstrumentError( + "the D7 payload does not describe this instrument/reference/workload: " + + "; ".join(f"{k} pinned {str(payload[k])[:12]!r} but observed " + f"{observed[k][:12]!r}" for k in mismatched)) + + # --- C2 shape ----------------------------------------------------- + if not D7_ATTESTATION.is_file(): + raise InstrumentError( + f"a D7 payload is present but {D7_ATTESTATION.name} is not. §6 requires a " + "DETACHED attestation in a descendant commit; a payload alone is a draft.") + att = _read_json_or_refuse(D7_ATTESTATION, "D7 attestation") + if att.get("kind") != D7_ATTESTATION_KIND or att.get("schema") != D7_SCHEMA: + raise InstrumentError( + f"{D7_ATTESTATION.name} does not declare itself a D7 attestation " + f"(kind={att.get('kind')!r}, schema={att.get('schema')!r})") + missing = [k for k in D7_ATTESTATION_KEYS if k not in att] + if missing: + raise InstrumentError( + "the D7 attestation is incomplete, missing: " + ", ".join(missing)) + + # --- exact-byte hash ---------------------------------------------- + # §6 says sha256 of the EXACT payload bytes. Not a canonical-JSON + # re-serialisation: that would let two different files claim one hash, + # which is the opposite of what an attestation is for. + exact = sha256_bytes(raw_payload) + declared = str(att["payload_sha256"]) + if not _HEX64.match(declared): + raise InstrumentError(f"payload_sha256 is not a sha256: {declared[:24]!r}") + if declared != exact: + raise InstrumentError( + f"the D7 attestation attests payload_sha256 {declared[:12]} but the payload's " + f"exact bytes hash to {exact[:12]}") + + # --- the frozen protocol: structure verified, values never read ---- + shape = _d7_protocol_problems(payload) + if shape: + raise InstrumentError( + "the D7 payload does not carry a preregistration §6 would recognise: " + + "; ".join(shape) + ". The gate never reads a threshold VALUE, but a " + "freeze whose protocol is structurally empty is not a freeze.") + + # --- git identity: repo, blob, commit, ancestry -------------------- + if freeze_root is None: + raise InstrumentError( + "the D7 freeze names commits but is not inside a git repository, so its object " + "identity cannot be verified. Fail-closed: unverifiable is not verified.") + canonical = _repo_relative(root, D7_PAYLOAD) + att_rel = _repo_relative(root, D7_ATTESTATION) + if canonical is None or att_rel is None: + raise InstrumentError("the D7 objects are not inside the repository containing them") + if str(att["payload_path"]) != canonical: + raise InstrumentError( + f"the attestation attests {str(att['payload_path'])!r}, but this instrument reads " + f"its payload from {canonical!r}: an attestation may not choose which file it is " + "about") + + c1 = str(att["payload_commit_sha"]) + if not _HEX40.match(c1): + raise InstrumentError(f"payload_commit_sha is not a full commit sha: {c1[:24]!r}") + rc, _ = _git_in(root, "rev-parse", "--verify", "--quiet", f"{c1}^{{commit}}") + if rc != 0: + raise InstrumentError( + f"payload_commit_sha {c1[:12]} is not a commit in this repository") + + # --- the instrument anchor: provenance, not current position ------- + # + # C1 declares S, the accepted #263-A source commit. The gate proves S + # rather than comparing it to wherever the repository is standing: + # + # S exists, and contains the instrument + # the instrument AT S hashes to the harness_digest C1 froze + # S is an ancestor of C1 + # + # and the rest of the chain is already proved below: C1 is a strict + # ancestor of C2, and C2 is found by `git log` in HEAD's history. So + # S <= C1 < C2 <= HEAD without ever requiring HEAD to equal anything. + anchor = str(payload[D7_PAYLOAD_ANCHOR]) + if not _HEX40.match(anchor): + raise InstrumentError( + f"{D7_PAYLOAD_ANCHOR} is not a full commit sha: {anchor[:24]!r}") + rc, _ = _git_in(root, "rev-parse", "--verify", "--quiet", f"{anchor}^{{commit}}") + if rc != 0: + raise InstrumentError( + f"{D7_PAYLOAD_ANCHOR} {anchor[:12]} is not a commit in this repository") + digest_at_anchor = harness_digest_at(root, anchor) + if digest_at_anchor is None: + raise InstrumentError( + f"{D7_PAYLOAD_ANCHOR} {anchor[:12]} does not contain the instrument sources (" + + ", ".join(_instrument_rel(src) for src in INSTRUMENT_SOURCES) + + "): it cannot be the accepted #263-A commit") + if digest_at_anchor != str(payload["harness_digest"]): + raise InstrumentError( + f"the instrument at {D7_PAYLOAD_ANCHOR} {anchor[:12]} hashes to " + f"{digest_at_anchor[:12]}, but C1 froze harness_digest " + f"{str(payload['harness_digest'])[:12]}: the anchor names a different " + "instrument than the one the freeze describes") + rc, _ = _git_in(root, "merge-base", "--is-ancestor", anchor, c1) + if rc != 0: + raise InstrumentError( + f"{D7_PAYLOAD_ANCHOR} {anchor[:12]} is not an ancestor of the payload commit " + f"{c1[:12]}: a freeze cannot precede the instrument it freezes") + + rc, blob_at_c1 = _git_in(root, "rev-parse", "--verify", "--quiet", f"{c1}:{canonical}") + if rc != 0 or not blob_at_c1: + raise InstrumentError(f"the D7 payload is not committed at {canonical!r} in {c1[:12]}") + if str(att["payload_blob_sha"]) != blob_at_c1: + raise InstrumentError( + f"the attestation attests payload_blob_sha {str(att['payload_blob_sha'])[:12]} " + f"but the payload's blob at {c1[:12]} is {blob_at_c1[:12]}") + rc, ondisk = _git_in(root, "hash-object", "--", str(D7_PAYLOAD)) + if rc != 0 or ondisk != blob_at_c1: + raise InstrumentError( + f"the D7 payload on disk ({ondisk[:12]}) is not the blob committed at " + f"{c1[:12]} ({blob_at_c1[:12]}): it was modified after it was frozen") + + # C2 must live in a STRICTLY LATER commit. Same-commit is not a + # detached attestation, it is a footnote. + rc, c2 = _git_in(root, "log", "-1", "--format=%H", "--", att_rel) + if rc != 0 or not _HEX40.match(c2): + raise InstrumentError( + f"{D7_ATTESTATION.name} is not committed in this repository: an uncommitted " + "attestation is a local edit, not an owner's act") + if c2 == c1: + # DEFENSIVE AND UNCONSTRUCTIBLE. §6 requires a descendant commit, + # and a same-commit state cannot be built with ordinary git: the + # attestation would have to contain the sha of the commit that + # contains the attestation, and git shas are content-addressed. The + # guard stays because "cannot currently be built" is not "cannot + # exist" — a hand-crafted object or a future tool could present one. + # It is untested for that reason, and said so rather than faked with + # a mocked git. + raise InstrumentError( + f"the D7 attestation is in the SAME commit as the payload ({c1[:12]}). §6 " + "requires a descendant commit: an attestation written in the act it attests to " + "proves only that both were typed at once.") + rc, _ = _git_in(root, "merge-base", "--is-ancestor", c1, c2) + if rc != 0: + raise InstrumentError( + f"the D7 attestation's commit {c2[:12]} is not a descendant of the payload " + f"commit {c1[:12]}: it attests a history it is not in") + good, detail = _committed_blob_matches(root, c2, att_rel, D7_ATTESTATION) + if not good: + raise InstrumentError(f"the D7 attestation is not its committed blob: {detail}") + + # --- C2 bindings and ratification binding -------------------------- + bindings = att["bindings"] + if not isinstance(bindings, dict): + raise InstrumentError("the D7 attestation's bindings are not an object") + rebound = [k for k in D7_PAYLOAD_BINDING_KEYS + if str(bindings.get(k, "")) != str(payload[k])] + if rebound: + raise InstrumentError( + "the D7 attestation re-binds values the payload froze differently: " + + ", ".join(rebound)) + if att["ratification_binding"] != payload["ratification"]: + raise InstrumentError( + "the D7 attestation's ratification_binding does not equal the payload's " + "ratification: the attestation ratifies something other than what was frozen") + + _cells = payload["cells"] + _cell_count = len(_cells) if isinstance(_cells, dict) else 0 + pinned = { + **{k: str(payload[k]) for k in D7_PAYLOAD_BINDING_KEYS}, + "payload_commit_sha": c1, + "payload_blob_sha": blob_at_c1, + "payload_sha256": exact, + "attestation_commit_sha": c2, + "ratified_by": str(rat["owner"]), + "ratified_at": str(rat["ratified_at"]), + "signature": "unsigned (declared): two committed objects, which anyone with " + "repository write access could author", + D7_PAYLOAD_ANCHOR: anchor, + "instrument_at_anchor_digest": digest_at_anchor, + # SHAPE, never values: a #263-A artifact must not carry a threshold. + # Counts describe how much preregistration was found; they say + # nothing about what any of it says. + "protocol_fields_present": ", ".join(sorted(D7_PAYLOAD_PROTOCOL_KEYS)), + "protocol_cells_specified": str(_cell_count), + "protocol_cells_required": str(len(expected_d7_cells())), + "protocol_rollup_levels": ", ".join(D7_ROLLUP_LEVELS), + } + return IdentityGate( + armed=True, + reason=(f"D7 freeze verified: C1 payload at {c1[:12]}, C2 attestation at " + f"{c2[:12]} (descendant), exact-byte sha256 {exact[:12]}"), + pinned=pinned, observed=observed) + + +def _read_json_or_refuse(path: Path, what: str) -> dict[str, object]: + try: + obj = json.loads(path.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError) as e: # fail closed, never open + raise InstrumentError(f"a {what} exists but cannot be read: {e}") from e + if not isinstance(obj, dict): + raise InstrumentError(f"the {what} is not a JSON object") + return obj + + +def _repo_root(inside: Path) -> Path | None: + """The Git TREE ROOT, asked of git rather than guessed from a parent directory. + + This is load-bearing and was got wrong once. ``:`` resolves the + path from the root of the tree; only a path starting ``./`` or ``../`` is + read relative to the current directory. Treating the file's own directory as + the repository therefore produced ``:p022-...json`` for a file that + actually lives at ``docs/evidence/p022-...json`` — a lookup that fails for + every real layout, so no production freeze could ever have armed. The + throwaway fixtures put both objects at the root of their repository, where + the wrong model happens to be right, so every control agreed. + """ + rc, out = _git_in(inside if inside.is_dir() else inside.parent, + "rev-parse", "--show-toplevel") + if rc != 0 or not out: + return None + return Path(out) + + +def _repo_relative(repo: Path, path: Path) -> str | None: + """Path as git names it: relative to the TREE ROOT, forward slashes. + + None when the file is outside the repository — a case that must refuse + rather than silently degrade to a basename. + """ + try: + return path.resolve().relative_to(Path(repo).resolve()).as_posix() + except ValueError: + return None + + +@dataclass +class SessionIdentity: + """The candidate under test, frozen when the session starts. + + Separate from the gate on purpose: the candidate is the SUBJECT of the + measurement, not part of the instrument. Its drift does not mean the + instrument changed, it means the session is measuring two different things + and must stop. + """ + + path: str + sha256: str + bytes_len: int + frozen_at: str + measurements_taken: int = 0 + + @staticmethod + def freeze(candidate: Path) -> SessionIdentity: + digest, n = sha256_file(candidate) + return SessionIdentity(path=str(candidate), sha256=digest, bytes_len=n, + frozen_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())) + + def reverify(self) -> None: + """Re-read the candidate. Called between cells, never inside an interval.""" + digest, n = sha256_file(Path(self.path)) + if digest != self.sha256 or n != self.bytes_len: + raise InstrumentError( + f"the candidate binary changed during the session (was {self.sha256[:12]}, " + f"{self.bytes_len} bytes; now {digest[:12]}, {n} bytes) after " + f"{self.measurements_taken} measurement(s). The rest of this session is refused: " + "cells measured on two different binaries are not one measurement.") + + +# --- environment ----------------------------------------------------------- + + +def _cpu_model() -> str: + if sys.platform.startswith("linux"): + try: + for line in Path("/proc/cpuinfo").read_text(encoding="utf-8").splitlines(): + if line.startswith("model name"): + return line.split(":", 1)[1].strip() + except OSError: + pass + return platform.processor() or platform.machine() + + +def _total_ram_bytes() -> int | None: + if sys.platform.startswith("linux"): + try: + for line in Path("/proc/meminfo").read_text(encoding="utf-8").splitlines(): + if line.startswith("MemTotal:"): + return int(line.split()[1]) * 1024 + except (OSError, ValueError): + return None + if os.name == "nt": + class _MS(ctypes.Structure): + _fields_ = [("dwLength", ctypes.c_ulong), ("dwMemoryLoad", ctypes.c_ulong), + ("ullTotalPhys", ctypes.c_ulonglong), ("ullAvailPhys", ctypes.c_ulonglong), + ("ullTotalPageFile", ctypes.c_ulonglong), + ("ullAvailPageFile", ctypes.c_ulonglong), + ("ullTotalVirtual", ctypes.c_ulonglong), + ("ullAvailVirtual", ctypes.c_ulonglong), + ("ullAvailExtendedVirtual", ctypes.c_ulonglong)] + ms = _MS() + ms.dwLength = ctypes.sizeof(_MS) + if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(ms)): # type: ignore[attr-defined] + return int(ms.ullTotalPhys) + return None + + +def _tool_version(argv: list[str]) -> str: + try: + r = subprocess.run(argv, capture_output=True, check=False, timeout=60) + return (r.stdout or r.stderr).decode("utf-8", "replace").strip().splitlines()[0][:120] + except (OSError, subprocess.SubprocessError, IndexError): + return "" + + +def environment_fingerprint() -> dict[str, object]: + """§4. Recorded, not assumed — a baseline whose machine is unknown is a number.""" + return { + "platform": sys.platform, + "os": platform.platform(), + "cpu_model": _cpu_model(), + "cpu_count": os.cpu_count(), + "ram_bytes": _total_ram_bytes(), + "python": sys.version.split()[0], + "python_executable": sys.executable, + "dotnet_sdk": _tool_version(["dotnet", "--version"]), + "rustc": _tool_version(["rustc", "--version"]), + "runner_class": os.environ.get("RUNNER_NAME") or os.environ.get("HOSTNAME") or "local", + "ci": bool(os.environ.get("CI")), + } + + +# --- peak RSS, by a NAMED tool (§8) ---------------------------------------- + + +class RssProbe: + """Peak resident set of a child process, captured by a NAMED mechanism. + + POSIX: ``os.wait4`` — the kernel's own per-child accounting, ``ru_maxrss`` + for exactly the process we spawned. Chosen over ``/usr/bin/time -v`` as the + primary because GNU time is a package that may simply be absent (it is + absent on the container this was first calibrated on), and "the tool was + missing" is not a memory measurement. ``/usr/bin/time -v`` remains as the + documented fallback where wait4 is unavailable. + + Windows: a Job Object, read through ``QueryInformationJobObject`` for + ``PeakProcessMemoryUsed``. + + Anywhere else: None WITH A REASON, so a silent absence can never be read as + a measured zero. + """ + + def __init__(self) -> None: + self.reason = "" + if hasattr(os, "wait4"): + self.mechanism = "posix os.wait4 (ru_maxrss)" + elif os.name == "nt": + self.mechanism = "win32 job object (PeakProcessMemoryUsed)" + elif Path("/usr/bin/time").is_file(): + self.mechanism = "/usr/bin/time -v" + else: + self.mechanism = "none" + self.reason = f"no named RSS mechanism on {sys.platform}" + + # ru_maxrss is kilobytes on Linux and bytes on macOS/BSD. Recorded, because + # a memory number whose unit was guessed is worse than none. + @property + def maxrss_unit_bytes(self) -> int: + return 1 if sys.platform == "darwin" else 1024 + + def wrap(self, argv: list[str], tmp: Path) -> tuple[list[str], Path | None]: + if self.mechanism.startswith("/usr/bin/time"): + out = tmp / f"rss-{os.getpid()}-{time.monotonic_ns()}.txt" + return ["/usr/bin/time", "-v", "-o", str(out), *argv], out + return argv, None + + def read(self, sidecar: Path | None) -> int | None: + if sidecar is None or not sidecar.is_file(): + return None + for line in sidecar.read_text(encoding="utf-8", errors="replace").splitlines(): + if "Maximum resident set size" in line: + try: + return int(line.rsplit(":", 1)[1].strip()) * 1024 + except (ValueError, IndexError): + return None + return None + + def read_windows_peak(self, job: object | None) -> tuple[int | None, str]: + if os.name != "nt" or job is None: + return None, "" + class _IO(ctypes.Structure): + _fields_ = [("ReadOperationCount", ctypes.c_ulonglong), + ("WriteOperationCount", ctypes.c_ulonglong), + ("OtherOperationCount", ctypes.c_ulonglong), + ("ReadTransferCount", ctypes.c_ulonglong), + ("WriteTransferCount", ctypes.c_ulonglong), + ("OtherTransferCount", ctypes.c_ulonglong)] + class _EXT(ctypes.Structure): + _fields_ = [("BasicLimitInformation", ctypes.c_byte * 48), + ("IoInfo", _IO), + ("ProcessMemoryLimit", ctypes.c_size_t), + ("JobMemoryLimit", ctypes.c_size_t), + ("PeakProcessMemoryUsed", ctypes.c_size_t), + ("PeakJobMemoryUsed", ctypes.c_size_t)] + info = _EXT() + ok = ctypes.windll.kernel32.QueryInformationJobObject( # type: ignore[attr-defined] + job, 9, ctypes.byref(info), ctypes.sizeof(_EXT), None) + if not ok: + return None, "QueryInformationJobObject failed" + peak = int(info.PeakProcessMemoryUsed) + if peak == 0: + # Not a measured zero. A process that exits before the job + # assignment lands is never accounted, and reporting 0 bytes for it + # would be the most confident possible lie. + return None, "the child exited before job assignment; peak not accounted" + return peak, "" + + +# --- workloads ------------------------------------------------------------- + + +@dataclass(frozen=True) +class Workload: + id: str + population: str + kind: str + spec: dict[str, object] + + @property + def decisive(self) -> bool: + return self.population == "decisive" + + +def load_manifest() -> tuple[list[Workload], str]: + raw = MANIFEST.read_bytes() + data = json.loads(raw.decode("utf-8")) + out: list[Workload] = [] + for population in ("decisive", "calibration"): + for item in data[population]: + out.append(Workload(id=str(item["id"]), population=population, + kind=str(item["kind"]), spec=dict(item))) + ids = [w.id for w in out] + if len(set(ids)) != len(ids): + raise InstrumentError(f"the workload manifest has duplicate ids: {ids}") + # Normalized, like every other identity D7 freezes. `.gitattributes` pins + # this file to LF, but an attribute only governs files git checks out under + # it: a zip download or a clone predating the rule still differs, and C1 + # freezes this value. + return out, sha256_bytes(normalized_text(raw)) + + +def materialize_calibration(w: Workload, tmp: Path) -> Path: + """Generate a calibration workload deterministically. + + Generated rather than committed, and generated from the manifest's own + scale, so a calibration workload can never quietly become a decisive one by + somebody dropping a real project into a directory. + """ + gen = str(w.spec.get("generator")) + if gen == "refused": + p = tmp / f"{w.id}.json" + p.write_text(json.dumps({"ownir_version": 999_999, "module": w.id}), encoding="utf-8") + return p + if gen == "facts": + scale = _as_int(w.spec.get("scale", 1), 1) + doc = { + "ownir_version": 0, + "module": w.id, + "components": [{"name": f"C{i}", "kind": "class", "file": f"gen/{i}.cs", "line": i + 1} + for i in range(scale)], + "services": [], + "functions": [{"name": f"F{i}", "component": f"C{i % max(scale, 1)}", + "file": f"gen/{i}.cs", "line": i + 2, "statements": []} + for i in range(scale)], + "stats": {"generated": True, "scale": scale}, + } + p = tmp / f"{w.id}.json" + p.write_text(json.dumps(doc), encoding="utf-8") + return p + if gen == "csharp": + scale = _as_int(w.spec.get("scale", 1), 1) + d = tmp / w.id + d.mkdir(parents=True, exist_ok=True) + for i in range(scale): + (d / f"Gen{i}.cs").write_text( + "using System;\nusing System.IO;\n\n" + f"public class Gen{i}\n{{\n" + f" public void Run{i}()\n {{\n" + f" var s = new FileStream(\"g{i}.txt\", FileMode.OpenOrCreate);\n" + f" Console.WriteLine(s.Length);\n" + " }\n}\n", encoding="utf-8") + return d + raise InstrumentError(f"{w.id}: unknown calibration generator {gen!r}") + + +# --- the rung ladder ------------------------------------------------------- + + +@dataclass(frozen=True) +class Rung: + id: str + surface: str # "core" | "launcher" + needs: str # "none" | "facts" | "facts-refused" | "source" + phases: tuple[str, ...] + observability: str # what this interval can and cannot say + expect_rc: tuple[int, ...] # the exit codes that mean THIS RUNG DID ITS JOB + evidence: str # the post-condition proving it, checked untimed + why: str + + +RUNGS: tuple[Rung, ...] = ( + Rung("core-usage", "core", "none", + ("process-startup-core", "cli-argv-parse", "cli-usage-refusal"), "composed", + (2,), "usage-help", + "The ladder FLOOR: the smallest real invocation the production surface allows — the " + "process starts, parses argv, finds no document, writes a usage refusal and exits. It " + "is a LOWER BOUND on core startup, not startup itself. argv handling and the refusal " + "message are inside this interval and cannot be separated out through the production " + "surface without instrumentation #263-A is not authorized to add. Calling it 'startup' " + "would let a later subtraction hand D7 a phase nobody measured."), + Rung("core-parse-refused", "core", "facts-refused", + ("process-startup-core", "cli-argv-parse", "ownir-parse", "ownir-door-refusal"), + "composed", (2,), "door-refusal", + "A document the strict door refuses on its version. The read and parse happen; bridge " + "and analysis never do. Subtracting core-usage does NOT leave parse: it leaves the " + "ownir read+parse cost only under an assumption this instrument never measures — that " + "both invocations pay the same argv handling, and that cli-usage-refusal and " + "ownir-door-refusal cost the same. They are different phases writing different text on " + "different streams, so that second assumption is visibly an assumption. " + "The difference is therefore a DERIVED bound, labelled as such, and never presented as " + "a direct measurement of parse."), + Rung("core-full-human", "core", "facts", + ("process-startup-core", "cli-argv-parse", "ownir-parse", "bridge-lowering", + "analysis", "render-human"), "composed", + (0, 1), "verdict-human", + "The whole core path to the default surface. Exit 0 and exit 1 both mean a verdict was " + "produced — 1 is 'leaks found', not a failure — and any other code means this interval " + "timed something that is not the analysis path. bridge-lowering and analysis are not " + "separately observable through the production surface and are recorded as members of " + "this interval, not imputed from it."), + Rung("core-full-sarif", "core", "facts", + ("process-startup-core", "cli-argv-parse", "ownir-parse", "bridge-lowering", + "analysis", "render-sarif"), "composed", + (0, 1), "verdict-sarif", + "The same path to the SARIF surface. Against core-full-human it gives a renderer " + "DIFFERENCE, which is not the same quantity as rendering in isolation and is never " + "reported as if it were."), + Rung("launcher-e2e", "launcher", "source", + ("process-startup-launcher", "frontend-extraction", "process-startup-core", + "cli-argv-parse", "ownir-parse", "bridge-lowering", "analysis", + "render-human"), "composed", + (0,), "verdict-human", + "The user-visible whole, through the production launcher with the engine explicitly " + "selected. Each engine performs ITS OWN extraction: extraction is inside the elapsed " + "time, because an end-to-end number that shares one extraction between engines is a " + "core comparison wearing an end-to-end hat."), +) + +def _evidence_problem(kind: str, out: str, err: str) -> str: + """"" when the rung demonstrably did its job; otherwise why not. + + Each check reads what the invocation actually produced. Measured, not + assumed: the exit codes and streams below were probed against both engines + before being written down. + """ + if kind == "usage-help": + # Both engines print their driver banner to STDOUT and leave stderr + # empty; that split is what distinguishes an argv refusal from a door + # refusal, since both exit 2. The banner does NOT contain the word + # "usage" — the first version of this check asserted it did and refused + # every healthy floor cell, which is the same assume-instead-of-measure + # habit the check exists to catch. What it does contain, in both + # engines, is the name of the subcommand that was invoked. + if "ownir" not in out.lower(): + return ("stdout does not name the subcommand, so this was not the argv refusal it " + "claims to time") + if err.strip(): + return f"the usage path wrote to stderr ({err.strip()[:80]!r}); something else failed" + return "" + if kind == "door-refusal": + if out.strip(): + return "the strict door printed a verdict on stdout; the document was not refused" + if "error:" not in err.lower(): + return f"no refusal on stderr ({err.strip()[:80]!r}); the door did not refuse this" + return "" + if kind == "verdict-human": + if not out.strip(): + return "no verdict on stdout: the pipeline did not reach a rendered result" + return "" + if kind == "verdict-sarif": + try: + doc = json.loads(out) + except json.JSONDecodeError: + return "stdout is not JSON, so the SARIF renderer did not produce a document" + if not isinstance(doc, dict) or "runs" not in doc: + return "stdout is JSON but carries no SARIF 'runs', so this is not a SARIF verdict" + return "" + raise InstrumentError(f"unknown rung evidence kind {kind!r}") + + +# WITHDRAWN: a `launcher-extract` rung claiming to stop after extraction. +# +# It invoked the launcher with `--emit-facts` and was documented as "no core +# runs, so this isolates the frontend stage". That is false, and the launcher +# says so itself: --emit-facts copies the intermediate facts and then Stage 2 +# runs the engine anyway, so the interval actually contained launcher startup, +# extraction, core startup, parse, lowering, analysis AND rendering while +# recording itself as launcher startup plus extraction. That is precisely the +# defect the core-usage repair was about — an interval naming itself after a +# subset of what it contains — and a local run with no .NET on PATH hid it by +# failing at 127 before Stage 2 was ever reached. +# +# The honest options were to change the production launcher (out of scope here) +# or to measure the extractor process directly (a different surface, and a +# direct extractor invocation is not the launcher's extraction stage). So +# launcher-scoped extraction isolation is recorded as UNAVAILABLE instead of +# being invented. frontend-extraction remains measured as a member of the +# launcher-e2e interval. + +# Phases named by #262's Performance-gates, plus the frontend stage the brief +# adds as a diagnostic. Recorded here so a reader can see which are gate phases +# and which are not, without inferring it from a rung id. +PHASES = { + "process-startup-core": "user-visible? no — the child engine's own startup", + # Split, because one name for two actions put a phase in intervals that never + # performed it. Every real core invocation parses argv; only the floor rung + # writes a usage refusal, and only the version-refused rung writes a door + # refusal. A phase list has to mean "this interval did these things". + "cli-argv-parse": "the core CLI's argument handling, before any document is opened; present " + "in every real core invocation", + "cli-usage-refusal": "the driver banner a core invocation with no document writes before " + "exiting; unavoidably inside the floor rung, which is why that rung is " + "a bound on startup and not startup itself", + "ownir-door-refusal": "the strict door's refusal message for a document it will not accept " + "on its version", + "process-startup-launcher": "user-visible: what a caller waits for before anything happens", + "ownir-parse": "the ownir document read and validate", + "bridge-lowering": "facts -> Layer 2 -> core AST", + "analysis": "the worklist/lattice solve", + "render-human": "output serialization only (default surface)", + "render-sarif": "output serialization only (SARIF surface)", + "frontend-extraction": "C# -> facts; recorded, NOT D7-gated unless separately ratified", +} + + +# --- the noise floor and run invalidation (§7) ----------------------------- + + +NOISE_PROBE_ITERATIONS = 25 +# An INSTRUMENT-VALIDITY constant, not a performance budget. It says how much +# the machine may wobble before a measurement taken on it means nothing; it +# says nothing whatever about either engine, and it is not a D7 threshold. +# THREE policies, three different statistical quantities, one historical value. +# +# A single constant used to play all three roles, and the report claimed the +# reproducibility tolerance was "the noise floor recorded by the earlier run, +# not a chosen number". That was false twice over: the recorded limit IS this +# constant, so reading it back is reading the constant, and nothing about it +# tightens on a quiet machine. It is chosen. It was chosen before any of the +# runs that later failed against it, which is the only thing that makes it +# admissible at all. +# +# They are separated here so each can be argued about on its own terms. The +# VALUE is deliberately unchanged on this PR: moving a number after seeing which +# runs it rejects is a threshold fitted to a result, and that decision is not +# this change's to make. +NOISE_PROBE_MAX_RELATIVE_IQR = 0.35 # dispersion WITHIN one probe +NOISE_PROBE_MAX_DRIFT = 0.35 # opening probe vs closing probe +REPRODUCIBILITY_MAX_MEDIAN_CHANGE = 0.35 # one cell's median, run A vs run B + +# Retained under its old name because the report records it and older evidence +# reads it back. It is the probe dispersion limit and nothing else. +NOISE_FLOOR_MAX_RELATIVE_IQR = NOISE_PROBE_MAX_RELATIVE_IQR + + +def noise_probe() -> dict[str, object]: + """A fixed deterministic task, timed repeatedly, to size the machine's wobble. + + This is how a contended runner announces itself. A benchmark that widens its + own dispersion rather than refusing the environment is reporting the noise + as if it were the subject. + """ + samples = [] + for _ in range(NOISE_PROBE_ITERATIONS): + t0 = time.perf_counter_ns() + acc = 0 + for i in range(200_000): + acc = (acc + i * 2654435761) & 0xFFFFFFFF + samples.append(time.perf_counter_ns() - t0) + med = statistics.median(samples) + q = statistics.quantiles(samples, n=4) if len(samples) >= 4 else [med, med, med] + iqr = q[2] - q[0] + return {"median_ns": med, "iqr_ns": iqr, "min_ns": min(samples), + "relative_iqr": (iqr / med) if med else None, + "iterations": NOISE_PROBE_ITERATIONS, + "limit_relative_iqr": NOISE_FLOOR_MAX_RELATIVE_IQR} + + +def invalidation_reasons(before: dict[str, object], after: dict[str, object]) -> list[str]: + out = [] + for label, probe in (("before", before), ("after", after)): + rel = probe.get("relative_iqr") + if rel is None: + out.append(f"noise probe {label}: no median, so the floor is unknown") + elif _as_float(rel) > NOISE_PROBE_MAX_RELATIVE_IQR: + out.append(f"noise probe {label}: relative IQR {_as_float(rel):.3f} exceeds the " + f"{NOISE_PROBE_MAX_RELATIVE_IQR} floor — a contended or throttling runner") + b, a = before.get("median_ns"), after.get("median_ns") + if isinstance(b, (int, float)) and isinstance(a, (int, float)) and b: + drift = abs(a - b) / b + if drift > NOISE_PROBE_MAX_DRIFT: + out.append(f"the machine drifted {drift:.3f} between the opening and closing probes") + return out + + +# --- aggregation (§6) ------------------------------------------------------ + + +def summarize(samples: list[int], unit: str = "ns") -> dict[str, object]: + """median + dispersion + min, never mean-only. Raw is retained by the caller. + + The Rust-vs-Python comparison statistic is NOT here and must not be added + here: how two engines' numbers become one number is D7's to preregister, + and a helper that quietly offered a ratio would be choosing it. + """ + if not samples: + return {"n": 0} + med = statistics.median(samples) + out: dict[str, object] = { + "n": len(samples), + f"median_{unit}": med, + f"min_{unit}": min(samples), + f"mad_{unit}": statistics.median([abs(s - med) for s in samples]), + } + if len(samples) >= 4: + q = statistics.quantiles(samples, n=4) + out[f"iqr_{unit}"] = q[2] - q[0] + out[f"q1_{unit}"], out[f"q3_{unit}"] = q[0], q[2] + return out + + +# --- the kernel's per-child accounting ------------------------------------- + +# What wait4's rusage carries out of one interval, beside peak RSS. These are +# POSIX-only: they come from wait4 and Windows offers nothing that means the +# same thing, so off POSIX every one of them is None WITH A REASON. A reported +# zero minor-fault count for a platform that was never asked would be the most +# confident possible lie, and a downstream median over such zeros would look +# exactly like a measurement. +ACCOUNTING_FIELDS: tuple[str, ...] = ( + "cpu_user_ns", + "cpu_system_ns", + "minor_faults", + "major_faults", + "voluntary_context_switches", + "involuntary_context_switches", +) + +# Which of them are durations, so no summary ever labels a fault count "ns". +ACCOUNTING_UNITS: dict[str, str] = { + "cpu_user_ns": "ns", + "cpu_system_ns": "ns", + "minor_faults": "count", + "major_faults": "count", + "voluntary_context_switches": "count", + "involuntary_context_switches": "count", +} + +_NS_PER_SECOND = 1_000_000_000 + + +def rusage_seconds_to_ns(seconds: float) -> int: + """ru_utime / ru_stime arrive as float seconds; everything else here is ns. + + Rounded, not truncated. Truncation biases every sample the same direction, + and a systematic half-tick bias is both harder to see and worse to reason + about than a symmetric one of the same size. + """ + return round(seconds * _NS_PER_SECOND) + + +# --- the single place a clock starts --------------------------------------- + + +@dataclass +class Harness: + gate: IdentityGate + session: SessionIdentity + rss: RssProbe + tmp: Path + candidate: Path + warmup_discards: int + repetitions: int + seed: int + execution_order: list[str] = field(default_factory=list) + raw: list[dict[str, object]] = field(default_factory=list) + + # -- the firewall ------------------------------------------------------ + + def _assert_may_time(self, w: Workload) -> None: + """The one gate every timed measurement passes through. + + Deliberately stricter than "no PAIRED timed runs": a single-engine timed + run of a decisive workload is refused too. The brief's permitted list for + a decisive workload before the freeze is enumerate / hash / fetch / + availability-check / non-timed structural smoke, and a stopwatch appears + nowhere in it. + """ + if w.decisive and not self.gate.armed: + raise FirewallBreach( + f"refusing to time the DECISIVE workload {w.id!r}: the D7 freeze has not " + f"happened ({self.gate.reason}). Before the freeze a decisive workload may be " + "enumerated, hashed, fetched, availability-checked and smoke-tested without a " + "clock — nothing else. This is not a policy that can be waived from the command " + "line; arming the gate requires a verified D7 attestation.") + + # -- one measured interval --------------------------------------------- + + def _run_once(self, argv: list[str], env: dict[str, str], cwd: Path) -> dict[str, object]: + """Spawn, time, and read the kernel's accounting for that one child. + + Every identity check has already run and passed by the time this is + called: the notary's cost belongs outside the interval it protects. + + The interval is unchanged in meaning from the version that produced + every number already committed to this repository: t0, Popen, wait4, + elapsed. The rusage fields are parsed AFTER the clock stops, so widening + what is recorded does not widen what is measured. The two lines between + wait4 and elapsed were inside the interval before and are deliberately + left inside: moving them would tighten it, and a tightened interval + silently un-compares every future number against every recorded one. + """ + wrapped, sidecar = self.rss.wrap(argv, self.tmp) + job = None + if os.name == "nt" and self.rss.mechanism.startswith("win32"): + job = ctypes.windll.kernel32.CreateJobObjectW(None, None) # type: ignore[attr-defined] + peak: int | None = None + why = "" + # Absent until measured — never zero until measured. + accounting: dict[str, int | None] = dict.fromkeys(ACCOUNTING_FIELDS) + accounting_why = "" + t0 = time.perf_counter_ns() + proc = subprocess.Popen(wrapped, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + env=env, cwd=str(cwd)) + if job: + ctypes.windll.kernel32.AssignProcessToJobObject( # type: ignore[attr-defined] + job, int(proc._handle)) # type: ignore[attr-defined] + if self.rss.mechanism.startswith("posix"): + # Reap through wait4 so the kernel hands back THIS child's rusage. + _, status, ru = os.wait4(proc.pid, 0) + proc.returncode = os.waitstatus_to_exitcode(status) + rc = proc.returncode + elapsed = time.perf_counter_ns() - t0 + # --- the clock is stopped; everything below is bookkeeping ------- + peak = int(ru.ru_maxrss) * self.rss.maxrss_unit_bytes + accounting = { + "cpu_user_ns": rusage_seconds_to_ns(ru.ru_utime), + "cpu_system_ns": rusage_seconds_to_ns(ru.ru_stime), + "minor_faults": int(ru.ru_minflt), + "major_faults": int(ru.ru_majflt), + "voluntary_context_switches": int(ru.ru_nvcsw), + "involuntary_context_switches": int(ru.ru_nivcsw), + } + else: + rc = proc.wait() + elapsed = time.perf_counter_ns() - t0 + peak = self.rss.read(sidecar) + if peak is None and job: + peak, why = self.rss.read_windows_peak(job) + accounting_why = ( + "per-child CPU, fault and context-switch accounting comes from os.wait4's " + f"rusage, which is not available here (platform {sys.platform!r}, RSS " + f"mechanism {self.rss.mechanism!r}); these fields were not measured") + if job: + ctypes.windll.kernel32.CloseHandle(job) # type: ignore[attr-defined] + if sidecar is not None and sidecar.is_file(): + sidecar.unlink() + return {"elapsed_ns": elapsed, "rc": rc, "peak_rss_bytes": peak, + "rss_unavailable_reason": why or (self.rss.reason if peak is None else ""), + **accounting, + "accounting_unavailable_reason": accounting_why} + + # -- non-timed structural smoke (permitted on decisive workloads) ------ + + def smoke(self, w: Workload, path: Path | None) -> dict[str, object]: + """Availability and shape, with no clock and no resource sampling. + + Returns no duration field at all — not a null one. A smoke result that + carried an empty timing slot would be one careless edit away from being + filled in. + """ + present = path is not None and path.exists() + out: dict[str, object] = {"workload": w.id, "population": w.population, + "present": present, "tag": CALIBRATION_ONLY} + if present and path is not None and path.is_file(): + digest, n = sha256_file(path) + out["sha256"], out["bytes"] = digest, n + elif present and path is not None: + files = sorted(p for p in path.rglob("*.cs")) + out["cs_files"] = len(files) + return out + + # -- cells and the seeded interleave ----------------------------------- + + def argv_for(self, rung: Rung, engine: str, + target: Path | None) -> tuple[list[str], dict[str, str], Path]: + env = dict(os.environ) + env["PYTHONPATH"] = str(ROOT) + env["OWEN_RUST_CORE"] = str(self.candidate) + # The reference reads OWNLANG_DEBUG, and inheriting the ambient value + # would make an uncontrolled input part of what is measured. It only + # affects the internal-error path, so it cannot change analysis output + # on a successful run — but an identity that content-addresses ownlang/ + # does not cover an environment variable, so the measurement pins it + # rather than inheriting whatever the operator happened to export. + for uncontrolled in REFERENCE_ENV_PINNED_UNSET: + env.pop(uncontrolled, None) + if rung.surface == "core": + base = ([sys.executable, "-m", "ownlang", "ownir"] if engine == "python" + else [str(self.candidate), "ownir"]) + if rung.needs == "none": + return base, env, ROOT + assert target is not None + fmt = "sarif" if rung.id.endswith("sarif") else "human" + return [*base, str(target), "--format", fmt], env, ROOT + # launcher surface — the production shell entry point, both engines + sh = str(ROOT / "scripts/own-check.sh") + assert target is not None + return [_bash(), sh, "--engine", engine, "--format", "human", "--", str(target)], env, ROOT + + def verify_outcome(self, rung: Rung, argv: list[str], env: dict[str, str], + cwd: Path) -> dict[str, object]: + """Did this rung actually do the work it claims to time? Asked ONCE, untimed. + + The instrument previously recorded whatever the process did and summarised + it. With no .NET on PATH the launcher rungs exited 127 before doing + anything at all, and 12 of 44 cells reproducibly measured a + command-not-found path while the report called them reproduced. An exit + code nobody checked is not a measurement, it is a number. + + This runs outside every measured interval — with output captured, which + the timed path deliberately does not do — so its cost never reaches a + benchmark. + """ + r = subprocess.run(argv, capture_output=True, env=env, cwd=str(cwd), check=False, + timeout=1800) + out = r.stdout.decode("utf-8", "replace") + err = r.stderr.decode("utf-8", "replace") + problems = [] + if r.returncode not in rung.expect_rc: + problems.append( + f"exit {r.returncode}, but {rung.id} does its job only at " + f"{sorted(rung.expect_rc)}" + + (" — 127 is command-not-found, so the rung never ran" + if r.returncode == 127 else "")) + why = _evidence_problem(rung.evidence, out, err) + if why: + problems.append(why) + return {"expected_exit_codes": sorted(rung.expect_rc), "observed_exit_code": r.returncode, + "evidence": rung.evidence, "valid": not problems, "problems": problems} + + def measure_cell(self, rung: Rung, engine: str, w: Workload, target: Path | None, + regime: str) -> dict[str, object]: + """One (rung x engine x workload x regime) cell. Identity first, clock second.""" + self._assert_may_time(w) + self.session.reverify() # outside every interval, by construction + argv, env, cwd = self.argv_for(rung, engine, target) + + # Outcome BEFORE clock. A cell whose invocation did not do the rung's + # work is not timed at all: timing a failure path and reporting its + # dispersion is how 12 command-not-found cells once passed as a + # reproduced calibration. + outcome = self.verify_outcome(rung, argv, env, cwd) + if not outcome["valid"]: + return { + "rung": rung.id, "engine": engine, "workload": w.id, "regime": regime, + "phases": list(rung.phases), "observability": rung.observability, + "argv": ([*argv[:1], "<...>"] if rung.surface == "core" + else [*argv[:2], "<...>"]), + "outcome": outcome, + "timing": None, "peak_rss": None, "accounting": None, + "raw_elapsed_ns": [], "raw_accounting": [], + "not_timed_because": "the rung did not do its work; measuring it would time " + "the wrong path", + "tag": CALIBRATION_ONLY, + } + + discarded = [] + for _ in range(self.warmup_discards if regime == "warm" else 0): + discarded.append(self._run_once(argv, env, cwd)) + samples: list[dict[str, object]] = [] + for _ in range(self.repetitions): + samples.append(self._run_once(argv, env, cwd)) + self.session.measurements_taken += 1 + + rcs = sorted({_as_int(s["rc"]) for s in samples}) + # Every timed sample must also land on a declared code. The untimed + # verification proved the rung CAN do its work; this proves each timed + # iteration actually did. + stray = [c for c in rcs if c not in rung.expect_rc] + if stray: + outcome = {**outcome, "valid": False, + "problems": [*_as_list(outcome["problems"]), + f"timed iterations exited {stray}, outside " + f"{sorted(rung.expect_rc)}"]} + cell = { + "rung": rung.id, "engine": engine, "workload": w.id, "regime": regime, + "phases": list(rung.phases), "observability": rung.observability, + "outcome": outcome, + "argv": ([*argv[:1], "<...>"] if rung.surface == "core" + else [*argv[:2], "<...>"]), + "exit_codes": rcs, + "warmup_discarded": len(discarded), + "timing": summarize([_as_int(s["elapsed_ns"]) for s in samples]), + "peak_rss": summarize( + [_as_int(s["peak_rss_bytes"]) for s in samples if s["peak_rss_bytes"] is not None], + unit="bytes"), + "rss_mechanism": self.rss.mechanism, + "rss_unavailable_reason": next( + (str(s["rss_unavailable_reason"]) for s in samples + if s["peak_rss_bytes"] is None and s["rss_unavailable_reason"]), ""), + # Summarized over the samples that HAVE the field. Where the + # platform offers no rusage every one of these is {"n": 0} and the + # reason below says why — an absence that reads as an absence, + # rather than a median of zeros that reads as a flat measurement. + "accounting": {name: summarize( + [_as_int(s[name]) for s in samples if s[name] is not None], + unit=ACCOUNTING_UNITS[name]) for name in ACCOUNTING_FIELDS}, + "accounting_unavailable_reason": next( + (str(s["accounting_unavailable_reason"]) for s in samples + if s["accounting_unavailable_reason"]), ""), + "raw_elapsed_ns": [_as_int(s["elapsed_ns"]) for s in samples], # §9: raw retained + "raw_peak_rss_bytes": [s["peak_rss_bytes"] for s in samples], + "raw_accounting": [{name: s[name] for name in ACCOUNTING_FIELDS} for s in samples], + "tag": CALIBRATION_ONLY, + } + return cell + + def run_calibration(self, workloads: list[Workload]) -> list[dict[str, object]]: + """Every cell, interleaved under the recorded seed. + + Interleaved rather than blocked: run all of Python and then all of Rust + and the machine's own drift becomes an engine difference. The actual + order is retained, because a randomization nobody can replay is a fond + memory rather than a method. + """ + rng = random.Random(self.seed) + materialized: dict[str, Path] = {} + for w in workloads: + materialized[w.id] = materialize_calibration(w, self.tmp) + + cells: list[tuple[Rung, str, Workload, str]] = [] + for rung in RUNGS: + for w in workloads: + if not _rung_accepts(rung, w): + continue + for engine in ("python", "rust"): + for regime in ("process-cold", "warm"): + cells.append((rung, engine, w, regime)) + + results: list[dict[str, object]] = [] + order = list(cells) + rng.shuffle(order) + for rung, engine, w, regime in order: + key = f"{rung.id}|{engine}|{w.id}|{regime}" + self.execution_order.append(key) + target = materialized.get(w.id) if rung.needs != "none" else None + results.append(self.measure_cell(rung, engine, w, target, regime)) + return results + + +def _bash() -> str: + """The bash that can run own-check.sh — never WSL's System32 stub on Windows.""" + if os.name != "nt": + return "bash" + for c in (os.environ.get("SHELL"), r"C:\Program Files\Git\bin\bash.exe", + r"C:\Program Files\Git\usr\bin\bash.exe"): + if c and Path(c).is_file(): + return c + return "bash" + + +def _rung_accepts(rung: Rung, w: Workload) -> bool: + if rung.needs == "none": + return w.id.endswith("facts-tiny") # one representative; startup has no workload + if rung.needs == "facts": + return w.kind == "generated-facts" and w.spec.get("generator") == "facts" + if rung.needs == "facts-refused": + return w.spec.get("generator") == "refused" + if rung.needs == "source": + return w.kind in ("generated-source", "source-tree") + return False + + +# --- the reference identity ------------------------------------------------- + + +# The Python reference source. Its identity is a property of THIS directory, not +# of the repository's current position. +PYTHON_REFERENCE_PATH = "ownlang" + +# Environment inputs the reference reads that its content-addressed identity +# does NOT cover. Cleared for every measured invocation so the same reference +# source cannot behave two ways depending on the shell it was launched from. +REFERENCE_ENV_PINNED_UNSET = ("OWNLANG_DEBUG",) + + +def python_reference_commit(root: Path = ROOT) -> str: + """§12: the decisive measurement and the G3 correctness evidence must name the + SAME Python reference state, by commit SHA. + + This used to return ``git rev-parse HEAD``, which is not the reference — it + is wherever the repository happens to be standing. Every commit moved it, + including commits that only added evidence, so run A and run B of one pair + recorded two different "reference" identities while ownlang had not changed + a byte. Worse, at D7 the freeze creates a C1 commit and then a C2 commit, so + a correctly executed freeze would itself invalidate the reference binding it + had just written down: an alarm that counts its own installation as a + break-in. + + The reference commit is now the last commit that TOUCHED the reference + source. It moves when ownlang moves and at no other time. + """ + rc, out = _git_in(root, "log", "-1", "--format=%H", "--", PYTHON_REFERENCE_PATH) + return out if rc == 0 else "" + + +def python_reference_tree(root: Path = ROOT) -> str: + """The reference's CONTENT identity: the git tree object of ownlang. + + Content-addressed, so it is identical across two checkouts that hold the + same reference source regardless of history. Recorded beside the commit sha + as a cross-check — a commit sha alone cannot show that two artifacts saw the + same bytes, only that they named the same label. + """ + rc, out = _git_in(root, "rev-parse", f"HEAD:{PYTHON_REFERENCE_PATH}") + return out if rc == 0 else "" + + +# --- report ---------------------------------------------------------------- + + +def build_report(harness: Harness, cells: list[dict[str, object]], + manifest_digest: str, before: dict[str, object], + after: dict[str, object], workloads: list[Workload], + smoke: list[dict[str, object]]) -> dict[str, object]: + invalid = invalidation_reasons(before, after) + return { + "schema": 1, + "tag": CALIBRATION_ONLY, + "not_decision_evidence": ( + "CALIBRATION ONLY. These numbers validate the INSTRUMENT and are not evidence about " + "either engine. They cannot choose a threshold, a budget, a repetition count or a " + "comparison statistic; those are D7's, frozen before the decisive run. No decisive " + "workload was timed or resource-sampled to produce this file."), + "harness": { + "version": HARNESS_VERSION, + "digest": harness_digest(), + "warmup_discards": harness.warmup_discards, + "calibration_repetitions": harness.repetitions, + "repetitions_note": ( + "a CALIBRATION parameter for sizing the instrument, not the decisive N. The " + "decisive N and its escalation ladder are preregistered by D7."), + "seed": harness.seed, + "execution_order": harness.execution_order, + }, + "identity": { + "gate_armed": harness.gate.armed, + "gate_reason": harness.gate.reason, + "gate_observed": harness.gate.observed, + # What a payload must survive to arm this gate, written into the + # evidence so the report describes its own verifier instead of + # asking a reader to take the harness on trust. + "gate_requirements": IdentityGate.requirements(), + # Empty while dormant. Never carries a C2 VALUE — only which C2 + # fields were present — because a #263-A artifact that quoted a + # threshold would have leaked the number this module exists to + # keep out. + "gate_pinned": harness.gate.pinned, + "session_candidate": { + "path": harness.session.path, + "sha256": harness.session.sha256, + "bytes": harness.session.bytes_len, + "frozen_at": harness.session.frozen_at, + "measurements_taken": harness.session.measurements_taken, + }, + }, + "provenance": { + "tree_sha": _git("rev-parse", "HEAD"), + "tree_dirty": bool(_git("status", "--porcelain")), + "python_reference_commit": python_reference_commit(), + "python_reference_tree": python_reference_tree(), + "python_interpreter": sys.version.split()[0], + "workload_manifest_sha256": manifest_digest, + "environment": environment_fingerprint(), + "timestamp_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + }, + "regimes": { + "process-cold": "a fresh process every iteration, no in-process warmup. The default: " + "cheap, portable, and honestly named.", + "warm": f"steady state after {harness.warmup_discards} DISCARDED iterations of the " + "same cell. The process is still fresh each time; what is warm is the OS " + "and filesystem cache.", + "machine-cold": "NOT CLAIMED here. It exists only behind a documented reset protocol " + "(cache drop / reboot / fresh VM), and 'caches not pre-warmed' with " + "no reset step means a different kind of cold on Windows than on " + "Linux. A machine-cold claim without its reset protocol is " + "inadmissible, so this instrument does not make one.", + }, + "noise": {"before": before, "after": after, + "invalidated": bool(invalid), "invalidation_reasons": invalid}, + "phases": PHASES, + "rungs": [{"id": r.id, "surface": r.surface, "phases": list(r.phases), + "observability": r.observability, "expect_rc": list(r.expect_rc), + "evidence": r.evidence, "why": r.why} for r in RUNGS], + "unobservable_phases": { + "bridge-lowering": "not separately observable through either engine's production " + "surface; recorded as a member of the core-full-* interval.", + "analysis": "same — isolating it would need production instrumentation, which " + "#263-A is not authorized to add.", + "frontend-extraction (launcher-scoped isolation)": + "UNAVAILABLE. The launcher's --emit-facts copies the intermediate facts and then " + "runs the engine anyway, so an interval built on it contains the whole pipeline " + "and cannot isolate extraction. Isolating it would need either a production " + "launcher change or a direct extractor invocation, which is a different surface " + "and not the launcher's extraction stage. Recorded as unavailable rather than " + "invented; frontend-extraction is still measured as a member of launcher-e2e.", + }, + # A cell is only a measurement if the invocation did the rung's work. + # This block is the verdict on that, separate from whether the machine + # was quiet enough (that is "noise" above). + "outcomes": { + "valid": all(_as_obj(c.get("outcome")).get("valid") for c in cells), + "cells_timed": sum(1 for c in cells if c.get("timing")), + "cells_refused": sum(1 for c in cells if not _as_obj(c.get("outcome")).get("valid")), + "problems": [f"{c['rung']}|{c['engine']}|{c['workload']}|{c['regime']}: " + + "; ".join( + str(x) for x in + _as_list(_as_obj(c.get("outcome")).get("problems"))) + for c in cells if not _as_obj(c.get("outcome")).get("valid")], + "contract": {r.id: {"expected_exit_codes": sorted(r.expect_rc), + "evidence": r.evidence} for r in RUNGS}, + }, + "workload_populations": { + "decisive": [w.id for w in workloads if w.decisive], + "calibration": [w.id for w in workloads if not w.decisive], + }, + "decisive_smoke": smoke, + "cells": cells, + } + + +def _git(*args: str) -> str: + r = subprocess.run(["git", *args], capture_output=True, cwd=str(ROOT), check=False) + return r.stdout.decode("utf-8", "replace").strip() if r.returncode == 0 else "" + + +# --- selftest --------------------------------------------------------------- + + +# Whole TOKENS, never substrings. The first version matched substrings and +# promptly refused its own report: "calibration" and "iterations" both contain +# "ratio". Reading a proxy for the thing is the failure mode this project keeps +# rediscovering, and a key vocabulary is exactly where it hides. +COMPARISON_TOKENS = frozenset({ + "delta", "deltas", "ratio", "ratios", "speedup", "slowdown", "versus", "vs", + "faster", "slower", "improvement", "regression", +}) + + +def _key_tokens(key: str) -> set[str]: + return {t for t in re.split(r"[^a-z0-9]+", key.lower()) if t} + + +def engine_comparison_problems(report: dict[str, object]) -> list[str]: + """The instrument records each engine's own numbers and nothing derived from + both. How two engines' numbers become one number is D7's to preregister, so + a helper that quietly offered it here would be choosing it. + + Two structural rules, read off the report itself: + * every cell names exactly ONE engine and carries samples from that engine; + * no key anywhere in the report belongs to the comparison vocabulary. + """ + problems: list[str] = [] + cells = report.get("cells") + if isinstance(cells, list): + for i, cell in enumerate(cells): + if not isinstance(cell, dict): + continue + engine = cell.get("engine") + if not isinstance(engine, str) or not engine: + problems.append(f"cell {i} names no engine") + others = [k for k in cell + if isinstance(k, str) and any(e in k for e in ("python", "rust"))] + if others: + problems.append(f"cell {i} ({engine}) carries engine-named keys {others}: a cell " + "holds one engine's samples, never a comparison") + + def walk(node: object, path: str) -> None: + if isinstance(node, dict): + for k, v in node.items(): + if _key_tokens(str(k)) & COMPARISON_TOKENS: + problems.append(f"{path}.{k}: an engine-comparison key — that statistic is " + "D7's, frozen before the decisive run, and is not this " + "instrument's to invent") + walk(v, f"{path}.{k}") + elif isinstance(node, list): + for i, v in enumerate(node): + walk(v, f"{path}[{i}]") + + walk(report, "report") + return problems + + +# Everything two halves of a pair must agree on. A "reproduced" verdict compares +# one run against another; if they were measured against different source, a +# different reference, a different candidate binary or a different workload +# manifest, the comparison is between two different experiments and the word +# means nothing. +# +# This list is why it exists: run A and run B once diverged on tree_sha and +# python_reference_commit, because A was COMMITTED before B was measured and +# python_reference_commit() is `git rev-parse HEAD`. Committing evidence between +# the halves moved the recorded reference identity while ownlang had not +# changed at all. The procedure is now: measure both halves on ONE clean commit, +# writing outside the repository, verify identity, then commit both together. +PAIR_IDENTITY_FIELDS = ( + "tree_sha", "tree_dirty", "python_reference_commit", "python_reference_tree", + "workload_manifest_sha256", "harness_digest", "calibration_repetitions", + "warmup_discards", "candidate_sha256", "candidate_bytes", +) + + +def _pair_identity(report: dict[str, object]) -> dict[str, object]: + prov = _as_obj(report.get("provenance")) + harn = _as_obj(report.get("harness")) + cand = (_as_obj(report.get("identity")).get("session_candidate") or {}) + return { + "tree_sha": str(prov.get("tree_sha", "")), + "tree_dirty": prov.get("tree_dirty"), + "python_reference_commit": str(prov.get("python_reference_commit", "")), + "python_reference_tree": str(prov.get("python_reference_tree", "")), + "workload_manifest_sha256": str(prov.get("workload_manifest_sha256", "")), + "harness_digest": str(harn.get("digest", "")), + "calibration_repetitions": harn.get("calibration_repetitions"), + "warmup_discards": harn.get("warmup_discards"), + "candidate_sha256": str(_as_obj(cand).get("sha256", "")), + "candidate_bytes": _as_obj(cand).get("bytes"), + } + + +def reproduce(previous: Path, current: dict[str, object]) -> dict[str, object]: + """§9: a second run on the same environment reproduces the first WITHIN §7's policy. + + Not byte-identical — a report carries timestamps and an execution order, and + demanding byte equality would only prove the clock was frozen. What must + agree is each cell's median, within REPRODUCIBILITY_MAX_MEDIAN_CHANGE. + + That tolerance is a CHOSEN policy constant. This docstring used to say it was + "the noise floor the run itself recorded", so the check "tightens on a quiet + machine" — both false. It never tightened: the recorded limit was the same + constant, read back out of JSON and returning disguised as a measurement. + What makes the constant admissible is that it was chosen before the runs it + judges, not that it was derived from them. + + The EARLIER run's identity is recorded in the result. A verdict of + "reproduced" that names only one of the two runs cannot be recomputed by + anyone but the program that already reached it. + """ + raw_previous = previous.read_bytes() + old = json.loads(raw_previous.decode("utf-8")) + + # Fail-closed BEFORE comparing anything. A mismatched pair should not be + # producible, not merely detectable afterwards by a control reading the + # shipped files. + mine, theirs = _pair_identity(current), _pair_identity(old) + differ = [k for k in PAIR_IDENTITY_FIELDS if mine[k] != theirs[k]] + if differ: + raise InstrumentError( + "the two halves of this pair were not measured under one identity, so comparing " + "them would compare two different experiments: " + + "; ".join(f"{k} {theirs[k]!r} then {mine[k]!r}" for k in differ) + + ". Measure both halves on one clean commit, writing outside the repository, and " + "commit them together.") + # The POLICY constant, named for the quantity it bounds. Previously this read + # the probe's recorded limit back out of the earlier report, which is the + # same constant taking a detour through JSON and arriving disguised as a + # measurement. + tol = REPRODUCIBILITY_MAX_MEDIAN_CHANGE + def _by_cell(doc: dict[str, object]) -> dict[tuple[str, str, str, str], dict[str, object]]: + out: dict[tuple[str, str, str, str], dict[str, object]] = {} + for raw in _as_list(doc.get("cells")): + c = _as_obj(raw) + out[(str(c["rung"]), str(c["engine"]), + str(c["workload"]), str(c["regime"]))] = c + return out + + old_cells = _by_cell(old) + new_cells = _by_cell(current) + missing = sorted(set(old_cells) - set(new_cells)) + added = sorted(set(new_cells) - set(old_cells)) + disagreed: list[dict[str, object]] = [] + outcome_changed = [] + for key in sorted(set(old_cells) & set(new_cells)): + # Outcome identity first. Two runs that agree to the nanosecond while + # exiting differently did not reproduce a measurement, they reproduced a + # coincidence — and if both ran the wrong path, agreeing about it is the + # worst possible reassurance. + oa = _as_obj(old_cells[key].get("outcome")) + ob = _as_obj(new_cells[key].get("outcome")) + if oa.get("observed_exit_code") != ob.get("observed_exit_code") or \ + bool(oa.get("valid")) != bool(ob.get("valid")): + outcome_changed.append({ + "cell": "|".join(key), + "earlier": {"exit": oa.get("observed_exit_code"), "valid": oa.get("valid")}, + "later": {"exit": ob.get("observed_exit_code"), "valid": ob.get("valid")}}) + continue + if not ob.get("valid"): + continue # an invalid cell was never timed; nothing to compare + a = _as_float(_as_obj(old_cells[key].get("timing")).get("median_ns")) + b = _as_float(_as_obj(new_cells[key].get("timing")).get("median_ns")) + if not a or not b: + disagreed.append({"cell": "|".join(key), + "why": "a run produced no median"}) + continue + rel = abs(b - a) / a + if rel > tol: + entry: dict[str, object] = {"cell": "|".join(key), + "relative_change": rel, "tolerance": tol} + disagreed.append(entry) + return { + "tag": CALIBRATION_ONLY, + # Run A, named and hashed. Both halves of the pair are committed, so the + # verdict below can be recomputed from evidence instead of trusted. + "earlier_run": { + "path": previous.name, + "sha256": sha256_bytes(raw_previous), + "bytes": len(raw_previous), + **_pair_identity(old), + }, + "compared_cells": len(set(old_cells) & set(new_cells)), + "tolerance_relative": tol, + "tolerance_source": ("REPRODUCIBILITY_MAX_MEDIAN_CHANGE, a fixed policy constant. It is " + "CHOSEN, not derived from this run; what makes it admissible is that " + "it was chosen before the runs it judges, and it is not adjusted " + "after seeing which of them it rejects."), + "cells_only_in_earlier": ["|".join(k) for k in missing], + "cells_only_in_later": ["|".join(k) for k in added], + "cells_outside_tolerance": disagreed, + "cells_whose_outcome_changed": outcome_changed, + # TWO axes here, a third alongside in the report's admissibility block. + # + # outcomes_reproduced — both runs did the same work: the same cells + # exist and each one's outcome is identical. A disagreement is a defect + # in THIS HARNESS. + # timings_reproduced — the medians agree within the policy. A + # disagreement says the numbers did not settle, and does NOT by itself + # say why: it can be a contended runner, a genuinely variable + # workload, or a median estimate that is simply uncertain at this + # repetition count. Naming it "the environment" would be asserting one + # of three causes without evidence. + # environment_valid — the noise probe's own verdict, recorded in the + # report's noise block and carried into admissibility. + # + # `reproduced` keeps the meaning it has always had: everything agreed. + # It is the conjunction of the two axes above, NOT a renamed subset — + # a red result must not vanish because a word changed profession. + # + # The tolerance is untouched by this split. + "outcomes_reproduced": not (missing or added or outcome_changed), + "timings_reproduced": not disagreed, + "reproduced": not (missing or added or disagreed or outcome_changed), + } + + +def selftest() -> int: + """Instrument checks that take no measurement at all.""" + problems: list[str] = [] + workloads, digest = load_manifest() + if not any(w.decisive for w in workloads): + problems.append("the manifest declares no decisive workloads") + if not any(not w.decisive for w in workloads): + problems.append("the manifest declares no calibration workloads") + + # D7's metrics and the attribution taxonomy must stay explicitly related. + # Checked here and not only in a control, because the failure mode is drift: + # a phase added to PHASES later must be classified, never defaulted. + problems.extend(d7_vocabulary_problems()) + + gate = IdentityGate.load(digest, python_reference_commit()) + if gate.armed: + problems.append("the identity gate is ARMED: a D7 attestation is present, which #263-A " + "must never produce") + + # The firewall, exercised rather than asserted. + with tempfile.TemporaryDirectory(prefix="perf-selftest-") as td: + h = Harness(gate=gate, session=SessionIdentity("", "", 0, ""), rss=RssProbe(), + tmp=Path(td), candidate=Path("/nonexistent"), warmup_discards=1, + repetitions=1, seed=0) + for w in workloads: + try: + h._assert_may_time(w) + except FirewallBreach: + if not w.decisive: + problems.append(f"{w.id}: a calibration workload was refused") + else: + if w.decisive: + problems.append(f"{w.id}: a DECISIVE workload was admitted to a timed path " + "with the gate unarmed — the firewall does not hold") + + # The instrument must not EMIT an engine comparison. Checked on the report's + # structure rather than on the module's prose: the first version of this + # guard grepped the source for "ratio" and duly fired on the sentence + # explaining why there must not be one — a validator reading a proxy instead + # of the thing, which is the exact defect this project keeps paying for. + problems.extend(engine_comparison_problems({ + "cells": [{"engine": "python", "timing": {"median_ns": 1}}, + {"engine": "rust", "timing": {"median_ns": 2}}], + })) + + for p in problems: + print(f"FAIL[perf-instrument]: {p}") + if not problems: + print(f"ok[perf-instrument]: manifest {digest[:12]}…, " + f"{sum(1 for w in workloads if w.decisive)} decisive / " + f"{sum(1 for w in workloads if not w.decisive)} calibration workloads, " + f"gate dormant ({gate.reason.split(':')[0]}), firewall refuses every decisive " + f"workload, harness digest {harness_digest()[:12]}…") + return 1 if problems else 0 + + +def main(argv: list[str] | None = None) -> int: + ap = argparse.ArgumentParser(description="#263-A measurement instrument (calibration only)") + ap.add_argument("--selftest", action="store_true") + ap.add_argument("--calibrate", action="store_true") + ap.add_argument("--smoke-decisive", action="store_true") + ap.add_argument("--candidate", default=os.environ.get("OWEN_RUST_CORE", "")) + ap.add_argument("--repeat", type=int, default=DEFAULT_CALIBRATION_REPETITIONS, + help="CALIBRATION repetitions per cell. Not the decisive N.") + ap.add_argument("--warmup", type=int, default=DEFAULT_WARMUP_DISCARDS, + help="discarded warmup iterations") + ap.add_argument("--seed", type=int, default=20260910) + ap.add_argument("--out", default="") + ap.add_argument("--reproduce", default="", + help="an earlier CALIBRATION report; re-run and check §9 reproducibility") + a = ap.parse_args(argv) + + if a.selftest: + return selftest() + + workloads, digest = load_manifest() + gate = IdentityGate.load(digest, python_reference_commit()) + + if a.smoke_decisive: + rows = [] + for w in workloads: + if not w.decisive: + continue + p = ROOT / str(w.spec.get("path", "")) + rows.append({"workload": w.id, "population": w.population, + "declared_path": str(w.spec.get("path", "")), + "present": p.exists(), + "pin": w.spec.get("pin"), "tag": CALIBRATION_ONLY}) + print(json.dumps({"tag": CALIBRATION_ONLY, "decisive_smoke": rows, + "note": "availability and pins only; no clock, no resource sampling"}, + indent=2)) + return 0 + + if not a.calibrate: + ap.error("choose --selftest, --calibrate or --smoke-decisive") + + candidate = Path(a.candidate) + if not candidate.is_file(): + raise InstrumentError( + "--candidate / OWEN_RUST_CORE must name the production own-cli binary. The " + "instrument never discovers it: D3's locator contract is the launcher's, and a " + "benchmark that found its own binary would be measuring whichever one it found.") + + session = SessionIdentity.freeze(candidate) + before = noise_probe() + with tempfile.TemporaryDirectory(prefix="perf-cal-") as td: + h = Harness(gate=gate, session=session, rss=RssProbe(), tmp=Path(td), + candidate=candidate, warmup_discards=a.warmup, repetitions=a.repeat, + seed=a.seed) + cal = [w for w in workloads if not w.decisive] + cells = h.run_calibration(cal) + smoke = [{"workload": w.id, "present": (ROOT / str(w.spec.get("path", ""))).exists(), + "pin": w.spec.get("pin"), "tag": CALIBRATION_ONLY} + for w in workloads if w.decisive] + after = noise_probe() + report = build_report(h, cells, digest, before, after, workloads, smoke) + + # Fail-closed on the way OUT as well as on the way in: nothing this + # instrument writes may be an engine comparison. + emitted = engine_comparison_problems(report) + if emitted: + raise InstrumentError("the report would have carried an engine comparison: " + + "; ".join(emitted)) + + if a.reproduce: + report["reproducibility"] = reproduce(Path(a.reproduce), report) + + # The three axes, together, decide whether this report may be evidence of + # record. A CI leg proving the instrument stands up may pass without them; + # a committed calibration may not. + rep_block = _as_obj(report.get("reproducibility")) + noise_block = _as_obj(report.get("noise")) + invalidated = bool(noise_block.get("invalidated")) + report["admissibility"] = { + "outcomes_reproduced": rep_block.get("outcomes_reproduced"), + "timings_reproduced": rep_block.get("timings_reproduced"), + "environment_valid": not invalidated, + "admissible": bool(rep_block + and rep_block.get("outcomes_reproduced") + and rep_block.get("timings_reproduced") + and not invalidated), + "note": ("all three axes are required for a report of record. A run that fails " + "timings_reproduced has not established WHY: a contended runner, a variable " + "workload and an uncertain median estimate all look the same here."), + } + + text = json.dumps(report, indent=2, ensure_ascii=False) + "\n" + if a.out: + Path(a.out).write_text(text, encoding="utf-8") + print(f"wrote {a.out} ({len(cells)} cells, {CALIBRATION_ONLY})") + else: + print(text) + outcomes = _as_obj(report["outcomes"]) + if not outcomes["valid"]: + print("CALIBRATION REFUSED — cells whose invocation did not do the rung's work:", + file=sys.stderr) + for problem in _as_list(outcomes["problems"]): + print(f" {problem}", file=sys.stderr) + print("These were not timed. A report that summarised them would be measuring the " + "wrong path and calling the agreement reproducibility.", file=sys.stderr) + return 1 + if invalidated: + print("RUN INVALIDATED: " + + "; ".join(str(r) for r in _as_list(noise_block.get("invalidation_reasons"))), + file=sys.stderr) + return 1 + rep = report.get("reproducibility") + if isinstance(rep, dict) and not rep["outcomes_reproduced"]: + print(f"THE INSTRUMENT DID NOT REPRODUCE ITSELF: cells only in the earlier run " + f"{rep['cells_only_in_earlier']}, only in the later run " + f"{rep['cells_only_in_later']}, outcome changed " + f"{rep['cells_whose_outcome_changed']}", file=sys.stderr) + return 1 + if isinstance(rep, dict) and not rep["timings_reproduced"]: + print(f"TIMINGS DID NOT REPRODUCE: every outcome was identical, but these medians moved " + f"outside the policy: {rep['cells_outside_tolerance']}. This does not say why — a " + "contended runner, a variable workload and an uncertain median estimate are " + "indistinguishable from here. Recorded, and the tolerance is not raised to hide " + "it.", file=sys.stderr) + return 1 + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/round6/metrology.py b/scripts/round6/metrology.py new file mode 100644 index 00000000..e8d00b47 --- /dev/null +++ b/scripts/round6/metrology.py @@ -0,0 +1,245 @@ +#!/usr/bin/env python3 +"""#263-A Round 6 — variance characterisation. CALIBRATION_ONLY. + +Preregistered in docs/notes/p022-263a-round6-preregistration.md, which was +committed BEFORE this script produced a single number. Read that first: it fixes +the ladder, the repetition counts, the session count, and — crucially — what +each possible shape of the result licenses. Nothing here decides anything. + +This module produces NO verdict, applies NO tolerance, and never consults 0.35. +It touches no decisive workload: the only thing it ever spawns is the synthetic +helper in spin.c. + +It measures through ``perf_baseline.Harness._run_once`` on purpose. That is the +instrument's own timed interval — perf_counter_ns around Popen and wait4, output +to DEVNULL, RSS read from the kernel's per-child rusage. Round 6 exists to +characterise THAT interval, so re-implementing a lookalike here would +characterise a different one and call the resemblance a result. + +Usage: + metrology.py --calibrate --out scales.json + metrology.py --measure --scales scales.json --out dataset.json +""" + +from __future__ import annotations + +import argparse +import json +import os +import platform +import statistics +import subprocess +import sys +import tempfile +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent.parent +sys.path.insert(0, str(ROOT / "scripts")) + +import perf_baseline as pb # noqa: E402 + +HERE = Path(__file__).resolve().parent +SOURCE = HERE / "spin.c" +TAG = "CALIBRATION_ONLY" + +# Preregistered and not adjustable from the command line. +LADDER_MS = (1, 2, 4, 8, 16, 32, 64, 128) +REPETITIONS = (5, 15) +WARMUP = 2 +SESSIONS = 5 + + +def build(out_dir: Path) -> tuple[Path, str]: + """Compile the helper once and return it with its content identity.""" + binary = out_dir / "spin" + r = subprocess.run(["gcc", "-O2", "-o", str(binary), str(SOURCE)], + capture_output=True, check=False) + if r.returncode != 0: + raise SystemExit("helper did not compile: " + r.stderr.decode("utf-8", "replace")) + digest, _ = pb.sha256_file(binary) + return binary, digest + + +def _harness(tmp: Path, binary: Path) -> pb.Harness: + """A real Harness, so the timed interval is the instrument's own. + + The firewall is never consulted because no workload is ever passed to it — + ``_run_once`` takes argv directly. No decisive workload exists anywhere in + this module. + """ + _, digest = pb.load_manifest() + return pb.Harness(gate=pb.IdentityGate.load(digest), session=pb.SessionIdentity.freeze(binary), + rss=pb.RssProbe(), tmp=tmp, candidate=binary, + warmup_discards=WARMUP, repetitions=1, seed=1) + + +def _series(h: pb.Harness, binary: Path, iterations: int, reps: int) -> list[int]: + """warmup discards, then `reps` timed fresh-process runs. Raw ns, unsummarised.""" + env = dict(os.environ) + argv = [str(binary), str(iterations)] + for _ in range(WARMUP): + h._run_once(argv, env, ROOT) + out = [] + for _ in range(reps): + r = h._run_once(argv, env, ROOT) + if r["rc"] != 0: + raise SystemExit(f"helper exited {r['rc']}; the ladder is not measuring what it thinks") + out.append(int(r["elapsed_ns"])) # type: ignore[arg-type] + return out + + +def _spread(xs: list[int]) -> dict[str, float]: + """Dispersion, reported and never compared to anything.""" + med = statistics.median(xs) + q1, q3 = (statistics.quantiles(xs, n=4)[0], statistics.quantiles(xs, n=4)[2]) \ + if len(xs) >= 4 else (min(xs), max(xs)) + return { + "median_ns": med, + "mad_ns": statistics.median([abs(x - med) for x in xs]), + "iqr_ns": q3 - q1, + "min_ns": min(xs), + "max_ns": max(xs), + "n": len(xs), + } + + +def _scheduler_signal() -> dict[str, object]: + """What the machine was doing. A signal, not a control.""" + sig: dict[str, object] = { + "cpu_affinity": sorted(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else [], + "cpu_count": os.cpu_count(), + } + try: + sig["loadavg"] = os.getloadavg() + except OSError: + sig["loadavg"] = None + try: + status = Path("/proc/self/status").read_text(encoding="utf-8") + for line in status.splitlines(): + if line.startswith(("voluntary_ctxt_switches", "nonvoluntary_ctxt_switches")): + k, v = line.split(":") + sig[k.strip()] = int(v.strip()) + except OSError: + pass + try: + for line in Path("/proc/stat").read_text(encoding="utf-8").splitlines(): + if line.startswith("ctxt "): + sig["system_ctxt"] = int(line.split()[1]) + except OSError: + pass + return sig + + +def calibrate(out: Path) -> int: + """Setup pass: fix an iteration count per rung, once, and record it. + + A helper that re-derives its own duration each run is measuring a moving + target, so these counts are chosen here and then never touched again. + """ + with tempfile.TemporaryDirectory(prefix="r6-cal-") as td: + tmp = Path(td) + binary, digest = build(tmp) + h = _harness(tmp, binary) + floor = statistics.median(_series(h, binary, 0, 9)) / 1e6 + big = statistics.median(_series(h, binary, 10_000_000, 5)) / 1e6 + per_ms = 10_000_000 / max(big - floor, 1e-9) + + rungs = [] + for target in LADDER_MS: + want = target - floor + iters = max(0, round(want * per_ms)) + achieved = statistics.median(_series(h, binary, iters, 9)) / 1e6 + rungs.append({ + "target_ms": target, "iterations": iters, + "achieved_median_ms": round(achieved, 4), + "at_or_below_spawn_floor": want <= 0, + }) + print(f" {target:>4} ms target -> {iters:>10} iterations -> " + f"{achieved:7.3f} ms achieved" + + (" [AT/BELOW SPAWN FLOOR]" if want <= 0 else "")) + + payload = { + "schema": 1, "tag": TAG, "kind": "own.net/p022/round6-scales", + "not_decision_evidence": "Setup pass. Fixes the helper's work per rung. No verdict, no " + "tolerance, no threshold.", + "helper_sha256": digest, "helper_source": str(SOURCE.relative_to(ROOT)), + "spawn_floor_ms": round(floor, 4), "iterations_per_ms": round(per_ms, 1), + "warmup_discards": WARMUP, "rungs": rungs, + "scheduler": _scheduler_signal(), + "platform": platform.platform(), "timestamp_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", + time.gmtime()), + } + out.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + print(f"spawn floor {floor:.3f} ms; helper {digest[:12]}; wrote {out}") + return 0 + + +def measure(scales: Path, out: Path) -> int: + """Measurement pass: the preregistered ladder, five A/B sessions per cell.""" + plan = json.loads(scales.read_text(encoding="utf-8")) + cells = [] + with tempfile.TemporaryDirectory(prefix="r6-run-") as td: + tmp = Path(td) + binary, digest = build(tmp) + if digest != plan["helper_sha256"]: + raise SystemExit("the helper is not the one the setup pass calibrated") + h = _harness(tmp, binary) + for rung in plan["rungs"]: + for reps in REPETITIONS: + for session in range(SESSIONS): + before = _scheduler_signal() + a = _series(h, binary, rung["iterations"], reps) + b = _series(h, binary, rung["iterations"], reps) + after = _scheduler_signal() + sa, sb = _spread(a), _spread(b) + delta = abs(sb["median_ns"] - sa["median_ns"]) + cells.append({ + "target_ms": rung["target_ms"], "iterations": rung["iterations"], + "repetitions": reps, "session": session, + "a": sa, "b": sb, + "raw_a_ns": a, "raw_b_ns": b, + "absolute_median_shift_ns": delta, + "relative_median_shift": (delta / sa["median_ns"] + if sa["median_ns"] else None), + "scheduler_before": before, "scheduler_after": after, + }) + print(f" {rung['target_ms']:>4} ms, n={reps:<3} " + f"{SESSIONS} sessions done") + payload = { + "schema": 1, "tag": TAG, "kind": "own.net/p022/round6-metrology", + "not_decision_evidence": "Variance characterisation of the instrument's timed interval. " + "NO pass/fail tolerance is computed or applied here, and no " + "value in this file may be used as a D7 threshold.", + "preregistration": "docs/notes/p022-263a-round6-preregistration.md", + "helper_sha256": digest, "spawn_floor_ms": plan["spawn_floor_ms"], + "warmup_discards": WARMUP, "sessions_per_cell": SESSIONS, + "instrument_harness_digest": pb.harness_digest(), + "instrument_tree_sha": pb._git_in(ROOT, "rev-parse", "HEAD")[1], + "platform": platform.platform(), + "timestamp_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "cells": cells, + } + out.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + print(f"wrote {out}: {len(cells)} A/B sessions") + return 0 + + +def main() -> int: + ap = argparse.ArgumentParser(description="#263-A Round 6 metrology (CALIBRATION_ONLY)") + ap.add_argument("--calibrate", action="store_true") + ap.add_argument("--measure", action="store_true") + ap.add_argument("--scales", type=Path) + ap.add_argument("--out", type=Path, required=True) + a = ap.parse_args() + if a.calibrate: + return calibrate(a.out) + if a.measure: + if not a.scales: + raise SystemExit("--measure needs --scales from the setup pass") + return measure(a.scales, a.out) + raise SystemExit("choose --calibrate or --measure") + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/round6/spin.c b/scripts/round6/spin.c new file mode 100644 index 00000000..d215ff17 --- /dev/null +++ b/scripts/round6/spin.c @@ -0,0 +1,24 @@ +/* #263-A Round 6 metrology helper — CALIBRATION_ONLY. + * + * Deterministic work, no I/O, no allocation, no branching on data. Neither + * Rust nor Python product code: this exists so the duration ladder measures + * the INSTRUMENT's timed interval rather than either engine. + * + * Compiled rather than interpreted because the timed interval includes process + * spawn, and a Python interpreter's floor (~11.8 ms here) sits above most of + * the ladder. /bin/true spawns in ~1.14 ms, so a compiled helper can reach the + * 2 ms rung that a Python one could not. + */ +#include +#include + +int main(int argc, char **argv) { + if (argc < 2) return 2; + uint64_t n = strtoull(argv[1], NULL, 10); + volatile uint64_t x = 1; + for (uint64_t i = 0; i < n; i++) { + x = x * 1103515245ull + 12345ull; + } + /* x is read so the loop cannot be optimised away; the value is discarded. */ + return (x == 0xFFFFFFFFFFFFFFFFull) ? 1 : 0; +} diff --git a/scripts/round7/classify.py b/scripts/round7/classify.py new file mode 100644 index 00000000..d06ce1f3 --- /dev/null +++ b/scripts/round7/classify.py @@ -0,0 +1,214 @@ +#!/usr/bin/env python3 +"""Round 7's outcome classifier — CALIBRATION_ONLY. + +The ONE implementation of the preregistered rules. Nothing else in the round may +restate them: a second copy is a second opinion, and the reading would then be +able to choose. It is pure by construction — numbers in, an outcome out, no +files, no clock, no I/O — so it can be exercised exhaustively before any +measurement exists. + +The rules, as ratified by the owner, per regime and per repetition count, where +A, B and C abbreviate D(A), D(B), D(C) — the median across sessions of +|median(second half) - median(first half)| for that arm: + + P4 the witness did not reproduce C <= 1.5A + P1 padded-image effect reproduces it C > 1.5A and B >= 3A + and (2/3)B <= C <= 1.5B + P2 padding-only effect insufficient B <= 1.5A and C >= 3A + P3 padding contributes, not the whole B >= 3A and C >= 2B + P5 inconclusive anything else + +plus the ratified degenerate guard: + + if A == 0 at either repetition count in a regime, that regime is P5. + +Why only A, and why exactly zero +-------------------------------- +The overlap algebra, done properly, is narrower than the previous draft claimed. +P1 is disjoint from every other rule unconditionally: its `C > 1.5A` clause +excludes P4 outright, and every other intersection forces B = 0 and then C = 0, +which contradicts `C > 1.5A`. The remaining overlaps -- P2 with P3, and those +two with P4 -- all require A = 0 AND B = 0 together. So the guard is not what +makes the set disjoint; `_OVERLAP_FREE_EXCEPT_AT_ZERO_A_AND_B` in the controls +proves that directly. + +The guard exists for a metrological reason instead. A is the multiplicative +reference for the whole scheme: 1.5A, 3A and 6A are meaningful only as multiples +of a baseline that has a size. At A = 0 any positive B or C is infinitely larger +than the baseline, and the rules still classify -- definitely, and meaninglessly. + +B = 0 has no such property and is NOT a refusal. A = 1, B = 0, C = 4 is a clean +P2: the padded arm shows no excess and the real binary does. Routing that to P5 +would discard one of the cleanest results this round can produce. + +No epsilon. A tolerance like `A < 0.01 ms` would be an absolute threshold chosen +with no preregistered basis -- the exact thing this round forbids. Exact zero is +a structural degenerate case, not another knob. +""" + +from __future__ import annotations + +import math +from dataclasses import dataclass +from fractions import Fraction + +# The ratified repetition counts. Not a knob: no other value may be measured. +REPETITION_COUNTS = (5, 15) +REGIMES = ("process-cold", "warm") +OUTCOMES = ("P1", "P2", "P3", "P4", "P5") + +OUTCOME_NAMES = { + "P1": "the padded-image effect reproduces the elevation", + "P2": "the padding-only effect is insufficient, the real binary is elevated", + "P3": "padding contributes but does not explain the whole", + "P4": "the witness did not reproduce", + "P5": "inconclusive", +} + + +class ClassifierError(Exception): + """The classifier was handed something it must not silently classify.""" + + +class AmbiguousOutcome(ClassifierError): + """More than one rule fired on one triple. + + Unreachable through `regime_outcome`, because the only triples where the + ratified rules overlap have A = 0 and the zero-A guard routes those to P5 + first. It is raised rather than resolved by precedence: a classifier that + quietly picked the first matching rule would hide exactly the defect that + made the previous draft's table unreadable. + """ + + +def _ratio(x: float) -> Fraction: + """Exact arithmetic for the comparisons, so 2/3 is 2/3 and not 0.6666... + + The boundaries are ratios of measured quantities, and a binary-float 2/3 + would decide the `(2/3)B <= C` edge by rounding direction rather than by the + preregistered rule. + """ + return Fraction(x).limit_denominator(10 ** 12) + + +def _check(name: str, value: float) -> Fraction: + if isinstance(value, bool) or not isinstance(value, (int, float, Fraction)): + raise ClassifierError(f"D({name}) is {type(value).__name__}, not a measurement") + if not math.isfinite(float(value)): + raise ClassifierError(f"D({name}) is {value!r}; a non-finite drift is not a " + "measurement and must not fall through to P5") + if value < 0: + raise ClassifierError(f"D({name}) is {value!r}; D is a median of ABSOLUTE " + "differences and cannot be negative") + return _ratio(value) + + +def rules_fired(a: float, b: float, c: float) -> tuple[str, ...]: + """Every rule the triple satisfies, in ratified order. Normally exactly one. + + Exposed so a control can count how many fire rather than trust that one + does. P5 is not among them: it is the absence of the others. + """ + A, B, C = _check("A", a), _check("B", b), _check("C", c) + three_halves = Fraction(3, 2) + fired = [] + if C <= three_halves * A: + fired.append("P4") + if C > three_halves * A and B >= 3 * A and Fraction(2, 3) * B <= C <= three_halves * B: + fired.append("P1") + if B <= three_halves * A and C >= 3 * A: + fired.append("P2") + if B >= 3 * A and C >= 2 * B: + fired.append("P3") + return tuple(fired) + + +def outcome_at(a: float, b: float, c: float) -> str: + """One repetition count, one regime. P1-P4, or P5 when no rule fires. + + Does NOT apply the zero-A guard: the guard is a property of a regime across + both repetition counts, and applying it here would hide from the controls + the very overlaps it exists to step around. + """ + fired = rules_fired(a, b, c) + if len(fired) > 1: + raise AmbiguousOutcome( + f"A={a!r}, B={b!r}, C={c!r} fires {list(fired)}: the outcome rules are " + "not mutually exclusive here, and a classifier that chose between them " + "would be choosing the result") + return fired[0] if fired else "P5" + + +@dataclass(frozen=True) +class RegimeOutcome: + regime: str + outcome: str + why: str + per_count: dict[int, str] + + +def regime_outcome(regime: str, by_count: dict[int, tuple[float, float, float]] + ) -> RegimeOutcome: + """One regime's verdict from its (A, B, C) triple at each repetition count. + + The three gates, in the ratified order: the zero-A guard, then the rules, + then agreement between n=5 and n=15. + """ + if regime not in REGIMES: + raise ClassifierError(f"{regime!r} is not a preregistered regime {REGIMES}") + missing = [n for n in REPETITION_COUNTS if n not in by_count] + extra = [n for n in by_count if n not in REPETITION_COUNTS] + if missing or extra: + raise ClassifierError( + f"{regime}: repetition counts must be exactly {list(REPETITION_COUNTS)} " + f"(missing {missing}, unexpected {extra}); no other count may be measured") + + # (1) The zero-A guard. Exact zero, either count, either regime-half. + zeroed = [n for n in REPETITION_COUNTS if _check("A", by_count[n][0]) == 0] + if zeroed: + return RegimeOutcome(regime, "P5", per_count={}, + why=f"D(A) is exactly 0 at n={zeroed}: A is the " + "multiplicative reference for 1.5A, 3A and 6A, and " + "against a baseline of zero any positive drift is " + "infinitely large. Definite, and metrologically " + "degenerate.") + + # (2) The rules, independently at each count. + per_count = {n: outcome_at(*by_count[n]) for n in REPETITION_COUNTS} + + # (3) Agreement WITHIN the regime. Disagreement BETWEEN regimes is not P5 — + # it is a cache- and state-sensitivity signal, and the caller reports it. + distinct = set(per_count.values()) + if len(distinct) > 1: + return RegimeOutcome(regime, "P5", per_count=per_count, + why=f"n=5 classified {per_count[5]} and n=15 classified " + f"{per_count[15]}; a rule must hold at both counts " + "within a regime to fire") + only = per_count[REPETITION_COUNTS[0]] + return RegimeOutcome(regime, only, per_count=per_count, + why=f"{only} held at n=5 and n=15: {OUTCOME_NAMES[only]}") + + +def read_round(by_regime: dict[str, dict[int, tuple[float, float, float]]] + ) -> dict[str, object]: + """Both regimes, classified independently, plus the cross-regime statement. + + A cold/warm split is reported as a finding about where the phenomenon lives. + Collapsing it into P5 would throw away the most informative thing this round + can produce. + """ + results = {r: regime_outcome(r, by_regime[r]) for r in REGIMES} + outcomes = {r: results[r].outcome for r in REGIMES} + split = outcomes["process-cold"] != outcomes["warm"] + return { + "per_regime": {r: {"outcome": results[r].outcome, "why": results[r].why, + "per_count": results[r].per_count} for r in REGIMES}, + "regime_split": split, + "regime_split_reading": ( + f"process-cold classified {outcomes['process-cold']} and warm classified " + f"{outcomes['warm']}. This is a cache- and state-sensitivity signal, NOT " + "P5: both regimes spawn a fresh process per iteration and differ only in " + "whether the first two are discarded." + if split else "both regimes classified the same; no split to report"), + "tag": "CALIBRATION_ONLY", + } diff --git a/scripts/round7/elfread.py b/scripts/round7/elfread.py new file mode 100644 index 00000000..b83a3c73 --- /dev/null +++ b/scripts/round7/elfread.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""A minimal ELF64 reader for the Round 7 structural preflight — CALIBRATION_ONLY. + +Why parse the file rather than shell out to readelf: the preflight's whole job +is to prove a structural claim about a linked binary, and a check that greps a +tool's prose is reading a rendering of the thing rather than the thing. The +fields below are read from the actual headers. It also keeps binutils off the +dependency list for everything except B4's disassembly fallback, which genuinely +needs a disassembler. + +Deliberately partial: 64-bit little-endian only, and only the structures B1-B4 +need. An ELF this does not understand is REFUSED rather than guessed at. +""" + +from __future__ import annotations + +import struct +from dataclasses import dataclass +from pathlib import Path + +PT_LOAD = 1 +SHT_SYMTAB = 2 +SHT_NOBITS = 8 + + +class NotAnElf64(Exception): + """The file is not a little-endian 64-bit ELF, so nothing below applies.""" + + +@dataclass(frozen=True) +class Section: + name: str + sh_type: int + flags: int + addr: int + offset: int + size: int + + +@dataclass(frozen=True) +class Segment: + p_type: int + flags: int + offset: int + vaddr: int + filesz: int + memsz: int + align: int + + +@dataclass(frozen=True) +class Symbol: + name: str + value: int + size: int + shndx: int + + +class Elf64: + def __init__(self, path: Path) -> None: + self.path = path + self.data = path.read_bytes() + if self.data[:4] != b"\x7fELF": + raise NotAnElf64(f"{path}: no ELF magic") + if self.data[4] != 2 or self.data[5] != 1: + raise NotAnElf64(f"{path}: not 64-bit little-endian (class={self.data[4]}, " + f"data={self.data[5]})") + (self.e_phoff, self.e_shoff) = struct.unpack_from(" list[Segment]: + out = [] + for i in range(self.e_phnum): + off = self.e_phoff + i * self.e_phentsize + p_type, flags = struct.unpack_from(" tuple[Segment, ...]: + return tuple(s for s in self.segments if s.p_type == PT_LOAD) + + @property + def mapped_bytes(self) -> int: + """Summed p_memsz of every PT_LOAD — what the kernel must map. + + The mapped size, not the file size, is what B3 compares: a file is read + from disk once and an image is mapped for the process's whole life. + """ + return sum(s.memsz for s in self.loads) + + # -- section headers --------------------------------------------------- + + def _raw_sections(self) -> list[tuple[int, int, int, int, int, int]]: + out = [] + for i in range(self.e_shnum): + off = self.e_shoff + i * self.e_shentsize + sh_name, sh_type, flags, addr, offset, size = struct.unpack_from( + " list[Section]: + raw = self._raw_sections() + if not raw: + return [] + strtab_off, strtab_size = raw[self.e_shstrndx][4], raw[self.e_shstrndx][5] + blob = self.data[strtab_off:strtab_off + strtab_size] + + def name_at(i: int) -> str: + end = blob.find(b"\x00", i) + return blob[i:end].decode("utf-8", "replace") + + return [Section(name_at(n), t, f, a, o, s) for n, t, f, a, o, s in raw] + + def section_named(self, name: str) -> Section | None: + return next((s for s in self.sections if s.name == name), None) + + def section_index_of_addr(self, addr: int) -> int | None: + for i, s in enumerate(self.sections): + if s.addr and s.addr <= addr < s.addr + s.size: + return i + return None + + # -- symbols ----------------------------------------------------------- + + def _symbols(self) -> list[Symbol]: + symtab = next((i for i, s in enumerate(self.sections) if s.sh_type == SHT_SYMTAB), + None) + if symtab is None: + return [] # stripped; B1 and B4 will say so + raw = self._raw_sections() + link = struct.unpack_from(" Symbol | None: + return next((s for s in self.symbols if s.name == name), None) + + def bytes_at_vaddr(self, vaddr: int, size: int) -> bytes | None: + """File bytes backing a virtual address range, or None if not backed. + + .bss has an address and no bytes; asking for its contents must return + nothing rather than whatever happens to sit at that file offset. + """ + i = self.section_index_of_addr(vaddr) + if i is None: + return None + sec = self.sections[i] + if sec.sh_type == SHT_NOBITS or vaddr + size > sec.addr + sec.size: + return None + start = sec.offset + (vaddr - sec.addr) + return self.data[start:start + size] diff --git a/scripts/round7/pad.c b/scripts/round7/pad.c new file mode 100644 index 00000000..639f77bd --- /dev/null +++ b/scripts/round7/pad.c @@ -0,0 +1,27 @@ +/* #263-A Round 7 arm B padding — CALIBRATION_ONLY. + * + * Arm B is arm A's work plus an inert image. This translation unit carries the + * image and nothing else: it defines no function, runs no code, and is never + * referenced by the work. The whole point is that arm B does exactly what arm A + * does while being as large as own-cli. + * + * const -> .rodata, so the padding is mapped read-only like a real image's + * text and constants rather than landing in a writable segment. + * volatile + external linkage -> neither the compiler nor --gc-sections may + * decide an unreferenced constant array is dead. B1 checks that this + * worked rather than trusting it. + * = { 1 } -> one non-zero element, so the array cannot be moved to .bss. A .bss + * array occupies no file bytes and would make arm B a large PROMISE + * of an image rather than an image. + * + * The element count is supplied at build time and recorded in the preflight, + * because it is tuned to match own-cli's mapped size and that target will move + * whenever own-cli does. + */ +#include + +#ifndef OWN_ROUND7_PAD_ELEMENTS +#error "OWN_ROUND7_PAD_ELEMENTS must be supplied by the preflight" +#endif + +const volatile uint64_t own_round7_padding[OWN_ROUND7_PAD_ELEMENTS] = { 1 }; diff --git a/scripts/round7/preflight.py b/scripts/round7/preflight.py new file mode 100644 index 00000000..93d65a97 --- /dev/null +++ b/scripts/round7/preflight.py @@ -0,0 +1,319 @@ +#!/usr/bin/env python3 +"""Round 7 arm construction and the B1-B4 structural preflight — CALIBRATION_ONLY. + +No clock is started here and none may be added. This builds the three arms and +answers four structural questions about arm B, each of which would silently +invalidate the round if it went the wrong way: + + B1 did the padding survive compilation and linking, or was it dropped? + B2 is the padding actually MAPPED, or merely present in the file? + B3 does arm B's mapped size match arm C's, to within one page? + B4 is arm B's work byte-identical to arm A's? + +All four are stop conditions. A padded binary whose padding was optimised away, +left unmapped, mis-sized, or accompanied by a change to the work confounds the +two things arm B exists to separate, and the failure would show up as a +measurement rather than as a build problem. + +Arm A and arm B are linked from THE SAME spin.o. Compiling the work twice and +comparing the results would test the compiler's determinism; linking one object +into both binaries removes the question instead of answering it, and B4 then +checks the only thing left that could differ — what the linker did. + + python scripts/round7/preflight.py --candidate --out +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import subprocess +import sys +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +from elfread import Elf64, NotAnElf64, Section, Symbol + +ROOT = Path(__file__).resolve().parent.parent.parent +WORK_SOURCE = ROOT / "scripts/round6/spin.c" # arm A is the Round 6 helper, unchanged +PAD_SOURCE = ROOT / "scripts/round7/pad.c" +CFLAGS = ("-O2",) # exactly Round 6's, so arm A is arm A +PAD_SYMBOL = "own_round7_padding" +PAD_MACRO = "OWN_ROUND7_PAD_ELEMENTS" # pad.c refuses to compile without it +WORK_SYMBOL = "main" +PAGE = 4096 +TAG = "CALIBRATION_ONLY" + + +def sha256_file(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _run(cmd: list[str]) -> None: + r = subprocess.run(cmd, capture_output=True) + if r.returncode != 0: + raise SystemExit(f"{cmd[0]} failed: {' '.join(cmd)}\n" + + r.stderr.decode("utf-8", "replace")) + + +def build_arms(out_dir: Path, target_mapped: int, max_attempts: int = 12 + ) -> dict[str, object]: + """Compile the work once, link arm A from it, and tune arm B onto arm C's size. + + The tuning loop is a build step, not a measurement: it links, reads the + resulting ELF's mapped size, and adjusts the element count. Its trace is + recorded so the final element count is not a number that simply appeared. + """ + out_dir.mkdir(parents=True, exist_ok=True) + work_obj = out_dir / "spin.o" + arm_a = out_dir / "arm-a" + arm_b = out_dir / "arm-b" + pad_obj = out_dir / "pad.o" + + _run(["gcc", *CFLAGS, "-c", "-o", str(work_obj), str(WORK_SOURCE)]) + _run(["gcc", *CFLAGS, "-o", str(arm_a), str(work_obj)]) + + elements = (target_mapped - Elf64(arm_a).mapped_bytes) // 8 + trace = [] + for _ in range(max_attempts): + _run(["gcc", *CFLAGS, "-c", f"-D{PAD_MACRO}={elements}", + "-o", str(pad_obj), str(PAD_SOURCE)]) + _run(["gcc", *CFLAGS, "-o", str(arm_b), str(work_obj), str(pad_obj)]) + mapped = Elf64(arm_b).mapped_bytes + delta = mapped - target_mapped + trace.append({"pad_elements": elements, "mapped_bytes": mapped, "delta": delta}) + if abs(delta) <= PAGE: + break + elements -= (delta + 7) // 8 + return {"work_object_sha256": hashlib.sha256(work_obj.read_bytes()).hexdigest(), + "arm_a": str(arm_a), "arm_b": str(arm_b), + "pad_elements": elements, "tuning_trace": trace, + "cflags": list(CFLAGS)} + + +# --- the four checks ------------------------------------------------------- + + +SHF_ALLOC = 0x2 +SHN_UNDEF = 0 +SHN_LORESERVE = 0xFF00 + + +def _padding_section(b: Elf64) -> tuple[Symbol | None, Section | None]: + """The section the padding symbol says it is in — st_shndx, not its address. + + st_shndx names the section outright. Looking it up by address instead would + be inferring the answer from a coincidence of ranges, and a non-allocated + section has address 0, where that inference quietly finds nothing at all. + """ + sym = b.symbol_named(PAD_SYMBOL) + if sym is None: + return None, None + if sym.shndx == SHN_UNDEF or sym.shndx >= SHN_LORESERVE or sym.shndx >= len(b.sections): + return sym, None + return sym, b.sections[sym.shndx] + + +def check_b1(b: Elf64) -> dict[str, object]: + """The padding survived linking, and its section is big enough to hold it.""" + sym, sec = _padding_section(b) + if sym is None: + return {"pass": False, "why": f"{PAD_SYMBOL} is absent from arm B's symbol " + "table: the compiler or the linker dropped it, " + "and arm B is not padded at all"} + if sec is None: + return {"pass": False, "symbol_size": sym.size, "shndx": sym.shndx, + "why": f"{PAD_SYMBOL} names section index {sym.shndx}, which is " + "undefined or reserved: it is a declaration, not an image"} + ok = sec.size >= sym.size + return {"pass": ok, "symbol_size": sym.size, "section": sec.name, + "section_size": sec.size, + "why": (f"{PAD_SYMBOL} is {sym.size} bytes in {sec.name} ({sec.size} bytes)" + if ok else + f"{sec.name} is {sec.size} bytes but {PAD_SYMBOL} claims {sym.size}")} + + +def check_b2(b: Elf64) -> dict[str, object]: + """The padding is MAPPED — inside a PT_LOAD, not merely present in the file. + + Padding that lives in the file and outside every PT_LOAD costs a disk read + and nothing else. Arm B would then be a large file rather than a large + image, and would test nothing the round is asking about. + """ + sym, sec = _padding_section(b) + if sym is None or sec is None: + return {"pass": False, "why": "no padding section to locate; see B1"} + if not sec.flags & SHF_ALLOC: + return {"pass": False, "section": sec.name, "section_flags": sec.flags, + "why": f"{sec.name} is not SHF_ALLOC: the padding occupies file bytes " + "the kernel never maps, so arm B is a large file rather than a " + "large image"} + lo, hi = sym.value, sym.value + sym.size + holder = next((s for s in b.loads if s.vaddr <= lo and hi <= s.vaddr + s.memsz), None) + if holder is None: + near = [f"[0x{s.vaddr:x},0x{s.vaddr + s.memsz:x})" for s in b.loads] + return {"pass": False, "section": sec.name, + "why": f"the padding spans [0x{lo:x},0x{hi:x}) and no PT_LOAD contains " + f"it; segments are {near}"} + return {"pass": True, "section": sec.name, "segment_vaddr": holder.vaddr, + "segment_memsz": holder.memsz, "segment_flags": holder.flags, + "why": f"the padding lies in SHF_ALLOC section {sec.name}, wholly inside " + f"the PT_LOAD at 0x{holder.vaddr:x} ({holder.memsz} bytes mapped)"} + + +def check_b3(b: Elf64, c: Elf64) -> dict[str, object]: + """Arm B's mapped size matches arm C's to within one page. + + Mapped, not file: the file is read once and the image is mapped for the + process's whole life, and it is the image arm B exists to imitate. File + sizes are recorded alongside because they are cheap and someone will ask. + """ + delta = b.mapped_bytes - c.mapped_bytes + ok = abs(delta) <= PAGE + return {"pass": ok, "arm_b_mapped_bytes": b.mapped_bytes, + "arm_c_mapped_bytes": c.mapped_bytes, "delta_bytes": delta, + "page_bytes": PAGE, "arm_b_file_bytes": len(b.data), + "arm_c_file_bytes": len(c.data), + "why": (f"arm B maps {b.mapped_bytes} bytes against arm C's " + f"{c.mapped_bytes}, a difference of {delta:+} bytes" + + ("" if ok else + f" — wider than one {PAGE}-byte page. The round STOPS for a " + "ruling rather than running with a mismatched arm."))} + + +def check_b4(a: Elf64, b: Elf64) -> dict[str, object]: + """Arm B's work is byte-identical to arm A's. + + Raw bytes first. Where linking leaves a relocated displacement inside the + function the bytes legitimately differ, and the preregistration permits + falling back to address-stripped disassembly — recording WHICH test decided, + because the two do not prove the same thing. + """ + sa, sb = a.symbol_named(WORK_SYMBOL), b.symbol_named(WORK_SYMBOL) + if sa is None or sb is None: + return {"pass": False, "test": "none", + "why": f"{WORK_SYMBOL} is missing from arm " + f"{'A' if sa is None else 'B'}'s symbol table"} + if sa.size != sb.size: + return {"pass": False, "test": "raw-bytes", "arm_a_size": sa.size, + "arm_b_size": sb.size, + "why": f"{WORK_SYMBOL} is {sa.size} bytes in arm A and {sb.size} in " + "arm B: the work is not the same work"} + ba, bb = a.bytes_at_vaddr(sa.value, sa.size), b.bytes_at_vaddr(sb.value, sb.size) + if ba is None or bb is None: + return {"pass": False, "test": "raw-bytes", + "why": f"{WORK_SYMBOL}'s bytes are not backed by file contents"} + if ba == bb: + return {"pass": True, "test": "raw-bytes", "size": sa.size, + "sha256": hashlib.sha256(ba).hexdigest(), + "why": f"{WORK_SYMBOL} is {sa.size} bytes and byte-identical in both " + "arms; the disassembly fallback was not needed"} + da, db = _disassemble(a.path, sa.value, sa.size), _disassemble(b.path, sb.value, sb.size) + ok = da is not None and da == db + return {"pass": ok, "test": "address-stripped-disassembly", + "arm_a_sha256": hashlib.sha256(ba).hexdigest(), + "arm_b_sha256": hashlib.sha256(bb).hexdigest(), + "why": (f"{WORK_SYMBOL}'s raw bytes differ, as relocation can make them; " + "the address-stripped disassembly is " + + ("identical" if ok else "NOT identical, so the work differs"))} + + +def _disassemble(path: Path, vaddr: int, size: int) -> list[str] | None: + """Instruction mnemonics only, with every address and displacement dropped.""" + r = subprocess.run(["objdump", "-d", "--start-address", hex(vaddr), + "--stop-address", hex(vaddr + size), str(path)], + capture_output=True) + if r.returncode != 0: + return None + out = [] + for line in r.stdout.decode("utf-8", "replace").splitlines(): + if ":\t" not in line: + continue + body = line.split(":\t", 1)[1] + text = body.split("\t", 1)[1] if "\t" in body else body + out.append(text.split("#", 1)[0].split("<", 1)[0].strip()) + return out + + +# --- the pass -------------------------------------------------------------- + + +def preflight(candidate: Path, out_dir: Path) -> dict[str, object]: + try: + arm_c = Elf64(candidate) + except NotAnElf64 as exc: + raise SystemExit(f"arm C is not usable: {exc}") from exc + + built = build_arms(out_dir, arm_c.mapped_bytes) + arm_a, arm_b = Elf64(Path(str(built["arm_a"]))), Elf64(Path(str(built["arm_b"]))) + + checks = {"B1": check_b1(arm_b), "B2": check_b2(arm_b), + "B3": check_b3(arm_b, arm_c), "B4": check_b4(arm_a, arm_b)} + failed = sorted(k for k, v in checks.items() if not v["pass"]) + return { + "tag": TAG, + "note": "structural preflight only; no clock was started and no timing exists", + "timestamp_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "sources": {p.name: {"sha256": sha256_file(p), "bytes": p.stat().st_size} + for p in (WORK_SOURCE, PAD_SOURCE)}, + "build": {k: v for k, v in built.items() if k != "arm_a" and k != "arm_b"}, + "arms": { + "A": _arm_record("synth", arm_a), + "B": _arm_record("synth-padded", arm_b), + "C": _arm_record("core-usage (own-cli)", arm_c), + }, + "checks": checks, + "all_passed": not failed, + "failed": failed, + "verdict": ("B1-B4 all pass; the round's structural precondition holds" + if not failed else + f"STOP: {failed} failed. Arm B does not test what it exists to " + "test, and no timing may be taken."), + } + + +def _rel(path: Path) -> str: + """Repo-relative where possible, bare name otherwise. + + An absolute build path is a fact about one machine's temporary directory and + would differ on every runner while claiming to identify the same binary. The + sha256 below is the identity; this is only a label. + """ + try: + return path.resolve().relative_to(ROOT).as_posix() + except ValueError: + return path.name + + +def _arm_record(role: str, e: Elf64) -> dict[str, object]: + return {"role": role, "name": _rel(e.path), "sha256": sha256_file(e.path), + "file_bytes": len(e.data), "mapped_bytes": e.mapped_bytes, + "pt_load_segments": len(e.loads)} + + +def main() -> int: + ap = argparse.ArgumentParser(description="Round 7 B1-B4 structural preflight") + ap.add_argument("--candidate", required=True, type=Path, + help="arm C: the production own-cli binary") + ap.add_argument("--out", type=Path, help="write the record here as JSON") + ap.add_argument("--build-dir", type=Path, help="where the arms are built") + args = ap.parse_args() + + out_dir = args.build_dir or (args.out.parent / "arms" if args.out + else Path("round7-arms")) + record = preflight(args.candidate.resolve(), out_dir) + blob = json.dumps(record, indent=2, sort_keys=False) + if args.out: + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(blob + "\n", encoding="utf-8") + print(f"wrote {args.out} ({record['verdict']})") + else: + print(blob) + return 0 if record["all_passed"] else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/round7/readout.py b/scripts/round7/readout.py new file mode 100644 index 00000000..a8a04e56 --- /dev/null +++ b/scripts/round7/readout.py @@ -0,0 +1,427 @@ +#!/usr/bin/env python3 +"""Round 7's reading — CALIBRATION_ONLY. + +This file computes nothing the preregistration did not already fix. It exists +separately from `runner.py` because the runner produces observations and a +reading interprets them, and because a reading written after seeing numbers is +a reading that can be steered by them. + +On provenance, stated precisely +------------------------------ +The operator recorded a pre-clock sha256 of this module (`0f14be8a491d`). +**Repository history does not independently establish that chronology**: this +file is absent from the authorised head `7ad4a0b` and enters the tree in the +single post-run commit, beside the dataset and the reading. An earlier revision +of this docstring called the claim "checkable rather than asserted", which was +itself an assertion dressed as a check — the exact defect this PR exists to +argue against, committed in the file whose job is to avoid it. + +What IS established by the repository, and is what the result rests on: the +definition of D, the P1-P5 rules, the zero-A guard, the attribution gates and +the stop rule were all committed BEFORE any measurement existed. This module +delegates every classification decision to that frozen `classify.py` rather than +restating it, and `round7-readout` recomputes the committed reading from the +committed dataset on every CI run. The formal outcome is therefore determined by +precommitted rules and a reproducible application of them, whatever order the +files happened to be written in. + +What is preregistered, quoted from the ratified design: + + D(arm, n, regime) = the median across the 10 sessions of + |median(second half) - median(first half)| + +on `elapsed_ns`. The rules that consume those triples live in `classify.py`, +which is the ONE implementation and is not restated here — this module hands it +numbers and prints what comes back. + +Mechanism attribution, also preregistered, applied only after an outcome fires +and only to the arm the fired rule names as elevated: + + Δ is second half - first half within a session; each row is the median + across the ten sessions of |Δ|. + + work median |Δ(cpu_user + cpu_system)| >= 0.5 x median |Δ elapsed| + scheduler median |Δ elapsed| >= 2 x median |Δ(cpu_user + cpu_system)| + AND median |Δ(vol + invol ctx switches)| >= 2 x arm A's + faults median |Δ(minor + major faults)| >= 2 x arm A's + +More than one may fire. None firing is itself reportable. + +Nothing here reads `0.35`, derives a threshold, or drops a session. +""" + +from __future__ import annotations + +import argparse +import json +import statistics +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import classify as cl + +ARMS = ("A", "B", "C") +HALVES = ("first", "second") +EXPECTED_RC = {"A": 0, "B": 0, "C": 2} +SESSIONS = 10 + +# Which arm a fired rule says is elevated. P4 reproduces nothing and P5 fires no +# rule, so neither licenses an attribution — that is the preregistration's "only +# after an outcome fires", not a judgement made once the numbers were visible. +ELEVATED_BY_OUTCOME: dict[str, tuple[str, ...]] = { + "P1": ("B", "C"), + "P2": ("C",), + "P3": ("B", "C"), + "P4": (), + "P5": (), +} + +ACCOUNTING_SUMS = { + "cpu_ns": ("cpu_user_ns", "cpu_system_ns"), + "context_switches": ("voluntary_context_switches", "involuntary_context_switches"), + "faults": ("minor_faults", "major_faults"), +} + + +class ReadoutRefused(Exception): + """The reading was handed something it must not interpret.""" + + +def _median(values: list[float]) -> float: + return statistics.median(values) + + +def _num(row: dict[str, object], field: str, where: str) -> float: + """One numeric field of one sample, narrowed fail-closed. + + `object` in, `float` out, and a refusal in between for anything that is not + a number. Coercing here would let a null accounting field -- the shape the + instrument deliberately produces off POSIX -- become 0.0 and be averaged + into a median as though it had been measured. + """ + value = row.get(field) + if isinstance(value, bool) or not isinstance(value, (int, float)): + raise ReadoutRefused(f"{where}: {field} is {value!r}, not a measurement") + return float(value) + + +def load_halves(record: dict[str, object]) -> dict[tuple[str, int, int, str, str], + list[dict[str, object]]]: + """Index every half by (regime, n, session, arm, half), refusing anything odd. + + Fail-closed on purpose. A reading that quietly skipped a malformed half would + report a median over whatever survived and call it the preregistered D. + """ + if record.get("run_valid") is not True: + raise ReadoutRefused( + f"run_valid is {record.get('run_valid')!r}; an invalid run is not read. " + f"abort={record.get('abort')!r}") + measurements = record.get("measurements") + if not isinstance(measurements, list): + raise ReadoutRefused("the record carries no measurements list") + + out: dict[tuple[str, int, int, str, str], list[dict[str, object]]] = {} + for entry in measurements: + if not isinstance(entry, dict): + raise ReadoutRefused(f"a measurement entry is {type(entry).__name__}, not a half") + key = str(entry.get("half")) + regime, n_s, s_s, arm, half = key.split("|") + n, session = int(n_s[1:]), int(s_s[1:]) + samples = entry.get("samples") + if not isinstance(samples, list) or len(samples) != n: + count = len(samples) if isinstance(samples, list) else "no" + raise ReadoutRefused(f"{key}: {count} samples for n={n}") + rows: list[dict[str, object]] = [] + for i, row in enumerate(samples): + if not isinstance(row, dict): + raise ReadoutRefused(f"{key} sample #{i} is {type(row).__name__}, not a row") + if int(_num(row, "rc", f"{key} sample #{i}")) != EXPECTED_RC[arm]: + raise ReadoutRefused( + f"{key} sample #{i} exited {row['rc']}, expected {EXPECTED_RC[arm]}; " + "the runner should already have refused this run") + rows.append(row) + out[(regime, n, session, arm, half)] = rows + return out + + +def session_deltas(halves: dict[tuple[str, int, int, str, str], list[dict[str, object]]], + regime: str, n: int, arm: str, field: str) -> list[float]: + """|median(second) - median(first)| for each of the ten sessions, in order.""" + deltas = [] + for session in range(1, SESSIONS + 1): + pair = [] + for half in HALVES: + key = (regime, n, session, arm, half) + if key not in halves: + raise ReadoutRefused(f"missing half {key}; the dataset is incomplete " + "and an incomplete D is not the preregistered D") + pair.append(_median([_num(r, field, str(key)) for r in halves[key]])) + deltas.append(abs(pair[1] - pair[0])) + return deltas + + +def signed_session_deltas(halves: dict[tuple[str, int, int, str, str], list[dict[str, object]]], + regime: str, n: int, arm: str, fields: tuple[str, ...]) -> list[float]: + """|Δ| per session for a SUM of accounting fields; Δ is second - first.""" + deltas = [] + for session in range(1, SESSIONS + 1): + pair = [] + for half in HALVES: + where = f"{regime}|n{n}|s{session}|{arm}|{half}" + rows = halves[(regime, n, session, arm, half)] + pair.append(_median([sum(_num(r, f, where) for f in fields) for r in rows])) + deltas.append(abs(pair[1] - pair[0])) + return deltas + + +def drift_table(halves: dict[tuple[str, int, int, str, str], list[dict[str, object]]] + ) -> dict[str, dict[int, dict[str, object]]]: + """D(arm, n, regime) on elapsed_ns, with the ten per-session values kept. + + The per-session deltas travel with the median because a median nobody can + recompute is a number that has to be trusted. + """ + table: dict[str, dict[int, dict[str, object]]] = {} + for regime in cl.REGIMES: + table[regime] = {} + for n in cl.REPETITION_COUNTS: + cell: dict[str, object] = {} + for arm in ARMS: + d = session_deltas(halves, regime, n, arm, "elapsed_ns") + cell[arm] = {"D_ns": _median(d), "D_ms": _median(d) / 1e6, + "per_session_delta_ns": d} + table[regime][n] = cell + return table + + +def attribution(halves: dict[tuple[str, int, int, str, str], list[dict[str, object]]], + regime: str, n: int, arm: str) -> dict[str, object]: + """The preregistered mechanism table for one arm, quoting its arithmetic.""" + elapsed = _median(session_deltas(halves, regime, n, arm, "elapsed_ns")) + cpu = _median(signed_session_deltas(halves, regime, n, arm, ACCOUNTING_SUMS["cpu_ns"])) + ctx = _median(signed_session_deltas(halves, regime, n, arm, + ACCOUNTING_SUMS["context_switches"])) + faults = _median(signed_session_deltas(halves, regime, n, arm, ACCOUNTING_SUMS["faults"])) + a_ctx = _median(signed_session_deltas(halves, regime, n, "A", + ACCOUNTING_SUMS["context_switches"])) + a_faults = _median(signed_session_deltas(halves, regime, n, "A", ACCOUNTING_SUMS["faults"])) + + # Every rule below is a ratio against something that can itself be zero, and + # `0 >= 2 * 0` is true. Without these guards all three mechanisms fire on a + # cell where NOTHING moved -- a confident attribution of a drift that does + # not exist. The owner found it by reading the rule; a control now drives it. + fired = [] + if elapsed <= 0: + # No wall-clock drift means there is no elevation to attribute. This + # precondition is not in the ratified table; it is the smallest thing + # that makes all three rules refuse the null case coherently, and it + # cannot change any outcome where a drift actually exists. + return { + "arm": arm, "n": n, + "median_abs_delta": {"elapsed_ns": elapsed, "cpu_ns": cpu, + "context_switches": ctx, "faults": faults}, + "arm_a_reference": {"context_switches": a_ctx, "faults": a_faults}, + "fired": [], + "reading": ("median |delta elapsed| is zero: there is no drift to " + "attribute, so no mechanism fires. Attributing a " + "mechanism to a drift of zero would be a verdict about " + "nothing"), + } + if cpu >= 0.5 * elapsed: + fired.append("work") + if elapsed >= 2 * cpu and ctx > 0 and ctx >= 2 * a_ctx: + fired.append("scheduler") + if faults > 0 and faults >= 2 * a_faults: + fired.append("faults") + return { + "arm": arm, "n": n, + "median_abs_delta": {"elapsed_ns": elapsed, "cpu_ns": cpu, + "context_switches": ctx, "faults": faults}, + "arm_a_reference": {"context_switches": a_ctx, "faults": a_faults}, + "fired": fired, + "reading": ("none of the three fired: the drift is visible in wall time and in " + "none of the accounting the kernel offers" + if not fired else "fired: " + ", ".join(fired)), + } + + +def read(record: dict[str, object]) -> dict[str, object]: + halves = load_halves(record) + drift = drift_table(halves) + + # Assembled explicitly rather than by comprehension: a drift table missing a + # regime or a repetition count must refuse by name, not escape as a KeyError. + # A reading that dies is a traceback; a reading that refuses is a finding. + by_regime: dict[str, dict[int, tuple[float, float, float]]] = {} + for regime in cl.REGIMES: + if regime not in drift: + raise ReadoutRefused(f"the drift table has no {regime!r} regime") + by_regime[regime] = {} + for n in cl.REPETITION_COUNTS: + if n not in drift[regime]: + raise ReadoutRefused( + f"{regime}: the drift table has no n={n}; a regime is classified " + "from both preregistered counts or not at all") + cell = drift[regime][n] + by_regime[regime][n] = tuple( # type: ignore[assignment] + float(cell[arm]["D_ns"]) for arm in ARMS) # type: ignore[index] + outcome = cl.read_round(by_regime) + + attributions: dict[str, object] = {} + for regime in cl.REGIMES: + fired = str(outcome["per_regime"][regime]["outcome"]) # type: ignore[index] + arms = ELEVATED_BY_OUTCOME[fired] + if not arms: + attributions[regime] = { + "applied": False, + "why": f"{regime} classified {fired}; the preregistration applies the " + "mechanism table only after an outcome fires and only to the arm " + "that rule names as elevated", + } + continue + attributions[regime] = { + "applied": True, "elevated_arms": list(arms), + "rows": [attribution(halves, regime, n, arm) + for arm in arms for n in cl.REPETITION_COUNTS], + } + + return { + "tag": "CALIBRATION_ONLY", + "readout_of": "docs/evidence/round7/p022-263a-round7-dataset.linux.json", + "D_definition": ("D(arm, n, regime) = median across the 10 sessions of " + "|median(second half) - median(first half)| on elapsed_ns"), + "drift": drift, + "outcome": outcome, + "mechanism_attribution": attributions, + "not_derived": ("no threshold, budget, floor or envelope is derived from any " + "number here; 0.35 is not consulted, reported or compared " + "against; no session was dropped and no run was repeated"), + } + + +def _selftest() -> int: + """Synthetic triples with known answers. Run BEFORE any real data existed.""" + problems = [] + + def fake(by_regime: dict[str, dict[int, tuple[float, float, float]]], + ) -> dict[str, object]: + ms: list[dict[str, object]] = [] + for regime, by_n in by_regime.items(): + for n, (a, b, c) in by_n.items(): + for arm, d in zip(ARMS, (a, b, c), strict=True): + for session in range(1, SESSIONS + 1): + for half in HALVES: + base = 1_000_000.0 + val = base + (d if half == "second" else 0.0) + ms.append({ + "half": f"{regime}|n{n}|s{session}|{arm}|{half}", + "samples": [ + {"elapsed_ns": val, "rc": EXPECTED_RC[arm], + "cpu_user_ns": 0, "cpu_system_ns": 0, + "minor_faults": 0, "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0} + for _ in range(n)], + }) + return {"run_valid": True, "measurements": ms} + + # Each case: (A, B, C) at both counts in both regimes -> the rule that must fire. + cases = [ + ((1.0, 3.0, 6.0), "P3"), # B >= 3A and C >= 2B (C=4 would be P1) + ((1.0, 1.0, 4.0), "P2"), # B <= 1.5A and C >= 3A + ((1.0, 3.0, 3.0), "P1"), # C > 1.5A, B >= 3A, (2/3)B <= C <= 1.5B + ((1.0, 3.0, 1.4), "P4"), # C <= 1.5A + ((0.0, 3.0, 4.0), "P5"), # the zero-A guard + ((1.0, 2.0, 2.0), "P5"), # no rule fires + ] + for triple, want in cases: + by_regime = {r: dict.fromkeys(cl.REPETITION_COUNTS, triple) + for r in cl.REGIMES} + got = read(fake(by_regime)) + for regime in cl.REGIMES: + actual = got["outcome"]["per_regime"][regime]["outcome"] # type: ignore[index] + if actual != want: + problems.append(f"{triple} in {regime}: got {actual}, want {want}") + applied = got["mechanism_attribution"][cl.REGIMES[0]]["applied"] # type: ignore[index] + if applied != bool(ELEVATED_BY_OUTCOME[want]): + problems.append(f"{triple}: attribution applied={applied} for {want}") + + # A regime that disagrees across counts is P5, and a cold/warm split is reported. + by_regime = {"process-cold": {5: (1.0, 3.0, 4.0), 15: (1.0, 1.0, 4.0)}, + "warm": {5: (1.0, 1.0, 4.0), 15: (1.0, 1.0, 4.0)}} + got = read(fake(by_regime)) + if got["outcome"]["per_regime"]["process-cold"]["outcome"] != "P5": # type: ignore[index] + problems.append("disagreement across n did not become P5") + if got["outcome"]["per_regime"]["warm"]["outcome"] != "P2": # type: ignore[index] + problems.append("warm should have classified P2") + if not got["outcome"]["regime_split"]: # type: ignore[index] + problems.append("a cold/warm split was not reported") + + # An invalid run is refused rather than read. + try: + read({"run_valid": False, "measurements": None, "abort": {"kind": "x"}}) + except ReadoutRefused: + pass + else: + problems.append("an invalid run was read instead of refused") + + # A stray rc is refused even if the runner somehow let it through. + bad = fake({r: dict.fromkeys(cl.REPETITION_COUNTS, (1.0, 3.0, 4.0)) + for r in cl.REGIMES}) + bad["measurements"][0]["samples"][0]["rc"] = 127 # type: ignore[index] + try: + read(bad) + except ReadoutRefused: + pass + else: + problems.append("a stray exit code was read instead of refused") + + # A missing half is refused, not silently averaged over what survived. + short = fake({r: dict.fromkeys(cl.REPETITION_COUNTS, (1.0, 3.0, 4.0)) + for r in cl.REGIMES}) + trimmed = list(short["measurements"]) # type: ignore[call-overload] + trimmed.pop() + short["measurements"] = trimmed + try: + read(short) + except ReadoutRefused: + pass + else: + problems.append("an incomplete dataset was read instead of refused") + + for p in problems: + print(f"FAIL[round7-readout]: {p}") + if not problems: + print("ok[round7-readout-selftest]: the preregistered D, the frozen classifier, " + "the attribution gate, and three fail-closed refusals. The full control, " + "with five refusals and the reproduction check, is `round7-readout` in " + "tests/test_round7_apparatus.py") + return 1 if problems else 0 + + +def main() -> int: + ap = argparse.ArgumentParser(description="Round 7 reading") + ap.add_argument("--dataset", type=Path) + ap.add_argument("--out", type=Path) + ap.add_argument("--selftest", action="store_true") + args = ap.parse_args() + if args.selftest: + return _selftest() + if not args.dataset: + ap.error("--dataset is required unless --selftest") + record = json.loads(args.dataset.read_text(encoding="utf-8")) + reading = read(record) + blob = json.dumps(reading, indent=2) + if args.out: + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(blob + "\n", encoding="utf-8") + print(f"wrote {args.out}") + else: + print(blob) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/round7/runner.py b/scripts/round7/runner.py new file mode 100644 index 00000000..602a1ae5 --- /dev/null +++ b/scripts/round7/runner.py @@ -0,0 +1,585 @@ +#!/usr/bin/env python3 +"""Round 7's measurement runner — CALIBRATION_ONLY. + +One transaction, in this order and no other: + + bind work iterations to the Round 6 2 ms rung + v + build arm A and arm B ONCE + v + B1-B4 on THOSE EXACT FILES + v + freeze sha256 and byte length of A, B and C + v + [plan mode stops here, before any clock] + v + time THOSE SAME FILES, re-verifying identity before every block + v + re-verify identity after the last block + +The order is the point. The committed preflight proves properties of specific +bytes; a runner that preflighted, discarded its temporary directory, rebuilt and +then measured would be proving things about one pair of arms and timing a +different pair that happened to share their names. That is this project's +oldest and favourite genre of defect and it does not get a sequel. + +Plan mode is not a flag that skips the timing loop -- it returns before the +timing function is ever reachable, and `round7-execution-contract` counts calls +to that function rather than trusting this sentence. + + python scripts/round7/runner.py --candidate --plan --out +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import sys +import time +from dataclasses import dataclass +from pathlib import Path +from typing import TYPE_CHECKING + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +import preflight as pf +import schedule as sch +from elfread import Elf64 + +if TYPE_CHECKING: + import perf_baseline as pb + +ROOT = Path(__file__).resolve().parent.parent.parent +SCALES = ROOT / "docs/evidence/round6/p022-263a-round6-scales.linux.json" +TARGET_RUNG_MS = 2 +WARMUP_DISCARDS = 2 # policy, not a knob: `warm` discards two, cold none +TAG = "CALIBRATION_ONLY" + + +class ExecutionContractBreach(Exception): + """The round was asked to measure something it did not preflight. + + Every breach carries structured `detail` so the abort record names the exact + spawn or the exact arm, rather than a sentence someone would have to parse. + One base class and one catch boundary: an invalid run leaves the same shaped + black box whichever contract it broke. + """ + + kind = "execution-contract" + + def detail(self) -> dict[str, object]: + return {} + + +class OutcomeContractBreach(ExecutionContractBreach): + """A timed process did not do the work its arm exists to do. + + Raised on the FIRST stray, not after finishing the half. Once a contract + breach is known, spawning more processes measures nothing anyone may use. + """ + + kind = "outcome-contract" + + def __init__(self, stray: dict[str, object]) -> None: + self.stray = stray + super().__init__( + f"{stray['block']} {stray['arm']}/{stray['half']} {stray['spawn_kind']} " + f"#{stray['index']} exited {stray['observed_rc']}, expected " + f"{stray['expected_rc']}. The run is INVALID and is not classified.") + + def detail(self) -> dict[str, object]: + return dict(self.stray) + + +class IdentityContractBreach(ExecutionContractBreach): + """An arm's bytes moved, or vanished, after the freeze.""" + + kind = "identity-contract" + + def __init__(self, when: str, role: str, expected: str, observed: str, + why: str) -> None: + self.when, self.role = when, role + self.expected, self.observed = expected, observed + super().__init__(f"{when}: arm {role} — {why}") + + def detail(self) -> dict[str, object]: + return {"when": self.when, "arm": self.role, + "expected_sha256": self.expected, "observed_sha256": self.observed} + + +# --- P0: a timed process must have done the work its arm exists to do -------- + +# Arm A and B are the Round 6 helper: argc >= 2 and a finished loop exits 0. +# Arm C is `own-cli ownir` with no document, which is the instrument's own +# `core-usage` floor and exits 2. +EXPECTED_RC = {"A": 0, "B": 0, "C": 2} + + +# --- P1: the work is the Round 6 2 ms rung, by binding rather than by memory -- + + +@dataclass(frozen=True) +class WorkBinding: + iterations: int + helper_sha256: str + achieved_median_ms: float + source: str + + def as_dict(self) -> dict[str, object]: + return {"iterations": self.iterations, "helper_sha256": self.helper_sha256, + "round6_achieved_median_ms": self.achieved_median_ms, + "source": self.source, "target_rung_ms": TARGET_RUNG_MS} + + +def bind_work(scales: Path = SCALES) -> WorkBinding: + """Read the iteration count off Round 6's committed ladder. + + The draft said "the Round 6 helper at its 2 ms rung" and left the number in + prose. A runner that re-derived it would be calibrating a new work count + after authorisation, which is a knob; a runner that hard-coded it would be a + number nobody could trace. It is read from the artifact that established it. + """ + doc = json.loads(scales.read_text(encoding="utf-8")) + rung = next((r for r in doc["rungs"] if r.get("target_ms") == TARGET_RUNG_MS), None) + if rung is None: + raise ExecutionContractBreach( + f"{scales.name} has no {TARGET_RUNG_MS} ms rung; the arms' work is " + "undefined and the round cannot start") + if not rung.get("iterations"): + raise ExecutionContractBreach( + f"the {TARGET_RUNG_MS} ms rung records {rung.get('iterations')!r} iterations") + return WorkBinding(int(rung["iterations"]), str(doc["helper_sha256"]), + float(rung["achieved_median_ms"]), pf._rel(scales)) + + +# --- P0-1: the preflighted bytes are the timed bytes ------------------------- + + +@dataclass(frozen=True) +class ArmIdentity: + role: str + path: Path + sha256: str + bytes_: int + + def as_dict(self) -> dict[str, object]: + return {"role": self.role, "name": pf._rel(self.path), + "sha256": self.sha256, "file_bytes": self.bytes_} + + +def _identity(role: str, path: Path) -> ArmIdentity: + data = path.read_bytes() + return ArmIdentity(role, path, hashlib.sha256(data).hexdigest(), len(data)) + + +def verify_identities(frozen: dict[str, ArmIdentity], when: str) -> None: + """Re-hash every arm and refuse if any byte moved. Outside every clock. + + Called before each block and after the last one. Cheap, and the alternative + is discovering mid-dataset that something rebuilt an arm underneath the + round. + """ + for role, want in frozen.items(): + if not want.path.is_file(): + raise IdentityContractBreach( + when, role, want.sha256, "", + f"{want.path.name} no longer exists; the bytes that passed B1-B4 are " + "gone and nothing may be timed against them") + got = _identity(role, want.path) + if got.sha256 != want.sha256 or got.bytes_ != want.bytes_: + raise IdentityContractBreach( + when, role, want.sha256, got.sha256, + f"changed since the freeze — {want.sha256[:12]} ({want.bytes_} bytes) " + f"became {got.sha256[:12]} ({got.bytes_} bytes). The preflight proved " + "properties of bytes that are no longer here.") + + +@dataclass(frozen=True) +class Prepared: + """Everything settled before the clock, typed rather than a bag of objects.""" + + binding: WorkBinding + build: dict[str, object] + checks: dict[str, dict[str, object]] + preflight_failed: list[str] + frozen: dict[str, ArmIdentity] + binding_ok: bool + binding_problem: str + arm_c_mapped_bytes: int + outcome: OutcomePreflight + + @property + def stop_conditions(self) -> list[str]: + stop = [] + if self.preflight_failed: + stop.append(f"B1-B4 failed: {self.preflight_failed}") + if not self.binding_ok: + stop.append(self.binding_problem) + if not self.outcome.all_passed: + stop.append("the untimed outcome preflight refused arm(s) " + + ", ".join(self.outcome.failed) + ": " + + "; ".join(f"arm {a} {self.outcome.arms[a].why}" + for a in self.outcome.failed)) + return stop + + +def check_binding(arm_a_sha256: str, binding: WorkBinding) -> tuple[bool, str]: + """Arm A must BE the Round 6 helper, by sha256, or the round stops. + + Separated from `prepare` so a control can exercise BOTH directions. A check + only ever shown matching input is a check nobody has tested, and this one + guards the difference between "460280 iterations means 2 ms" and "460280 + iterations means whatever this other binary happens to do". + + The refusal is deliberately terminal. Re-deriving an iteration count that + lands near 2 ms would be calibrating a new knob after authorisation, which + is the move the whole round forbids. + """ + if arm_a_sha256 == binding.helper_sha256: + return True, "" + return False, ( + f"arm A hashes {arm_a_sha256[:12]} but Round 6's helper is " + f"{binding.helper_sha256[:12]}: the arms are not the ladder's helper, so " + f"{binding.iterations} iterations no longer means {TARGET_RUNG_MS} ms here. " + "STOP — do not re-derive an iteration count after authorisation.") + + +def _argv_for(role: str, frozen: dict[str, ArmIdentity], binding: WorkBinding + ) -> list[str]: + """One definition of how each arm is invoked, shared by preflight and timing. + + Two copies would be two experiments: the untimed probe would verify one + command line and the clock would measure another. + """ + if role == "C": + return [str(frozen["C"].path), "ownir"] + return [str(frozen[role].path), str(binding.iterations)] + + +def measurement_env() -> dict[str, str]: + import os + + import perf_baseline as pb + env = dict(os.environ) + for uncontrolled in pb.REFERENCE_ENV_PINNED_UNSET: + env.pop(uncontrolled, None) + return env + + +@dataclass(frozen=True) +class ArmOutcome: + """One arm's untimed proof that it does the work it exists to do.""" + + role: str + passed: bool + expected_rc: int + observed_rc: int + contract: str + why: str + detail: dict[str, object] + + def as_dict(self) -> dict[str, object]: + return {"role": self.role, "pass": self.passed, "expected_rc": self.expected_rc, + "observed_rc": self.observed_rc, "contract": self.contract, + "why": self.why, **self.detail} + + +@dataclass(frozen=True) +class OutcomePreflight: + arms: dict[str, ArmOutcome] + ran: bool + + @property + def failed(self) -> list[str]: + return sorted(r for r, a in self.arms.items() if not a.passed) + + @property + def all_passed(self) -> bool: + return not self.failed + + def as_dict(self) -> dict[str, object]: + return {"ran": self.ran, "all_passed": self.all_passed, "failed": self.failed, + "arms": {r: a.as_dict() for r, a in self.arms.items()}, + "note": ("untimed; no clock was started for any of these probes" + if self.ran else + "not run: the arms did not pass B1-B4 or the work binding")} + + +def outcome_preflight(frozen: dict[str, ArmIdentity], binding: WorkBinding + ) -> OutcomePreflight: + """Prove each arm does its job BEFORE anything is timed. No clock here. + + Arm C is verified through the instrument's own `core-usage` rung — the same + `expect_rc` and the same `usage-help` evidence contract the frozen harness + applies, not a third restatement of it. Exit 2 alone is not enough: a + different failure can exit 2 too, which is why that contract also requires + stdout to name the subcommand and stderr to be empty. + + Arms A and B are the Round 6 helper and produce no output; their ratified + contract is the exit code. Their stream lengths are recorded as observations + rather than promoted to stop conditions. + """ + import subprocess + + import perf_baseline as pb + + env = measurement_env() + arms: dict[str, ArmOutcome] = {} + + for role in ("A", "B"): + r = subprocess.run(_argv_for(role, frozen, binding), capture_output=True, + cwd=str(ROOT), env=env) + passed = r.returncode == EXPECTED_RC[role] + arms[role] = ArmOutcome( + role=role, passed=passed, expected_rc=EXPECTED_RC[role], + observed_rc=r.returncode, + contract="exit code only; the helper writes nothing by construction", + why=(f"ran {binding.iterations} iterations and exited {r.returncode}" + if passed else + f"exited {r.returncode}, not {EXPECTED_RC[role]}: it did not do the " + "work, and timing it would measure the wrong path"), + detail={"stdout_bytes": len(r.stdout), "stderr_bytes": len(r.stderr)}) + + rung = next(x for x in pb.RUNGS if x.id == "core-usage") + outcome = _harness_for(frozen["C"].path).verify_outcome( + rung, _argv_for("C", frozen, binding), env, ROOT) + valid = bool(outcome["valid"]) + arms["C"] = ArmOutcome( + role="C", passed=valid, expected_rc=EXPECTED_RC["C"], + observed_rc=int(str(outcome["observed_exit_code"])), + contract=f"perf_baseline rung {rung.id!r}: expect_rc {sorted(rung.expect_rc)}, " + f"evidence {rung.evidence!r}", + why=(f"satisfied the instrument's own {rung.id} contract" if valid else + f"did not do the {rung.id} work: {outcome['problems']}"), + detail={"problems": outcome["problems"]}) + + return OutcomePreflight(arms=arms, ran=True) + + +def _harness_for(candidate: Path) -> pb.Harness: + """A harness instance, built only to reuse the frozen outcome verifier. + + Constructing it starts nothing: `verify_outcome` runs one untimed + subprocess and reads its streams. + """ + import perf_baseline as pb + return pb.Harness(gate=pb.IdentityGate.load(pb.load_manifest()[1]), + session=pb.SessionIdentity.freeze(candidate), rss=pb.RssProbe(), + tmp=candidate.parent, candidate=candidate, + warmup_discards=WARMUP_DISCARDS, repetitions=0, seed=0) + + +def prepare(candidate: Path, build_dir: Path) -> Prepared: + """Bind, build once, preflight THOSE files, freeze their identities. + + Everything up to the clock, and nothing that starts one. + """ + binding = bind_work() + arm_c = Elf64(candidate) + built = pf.build_arms(build_dir, arm_c.mapped_bytes) + arm_a_path = Path(str(built["arm_a"])) + arm_b_path = Path(str(built["arm_b"])) + arm_a, arm_b = Elf64(arm_a_path), Elf64(arm_b_path) + + checks = {"B1": pf.check_b1(arm_b), "B2": pf.check_b2(arm_b), + "B3": pf.check_b3(arm_b, arm_c), "B4": pf.check_b4(arm_a, arm_b)} + failed = sorted(k for k, v in checks.items() if not v["pass"]) + + frozen = {"A": _identity("A", arm_a_path), "B": _identity("B", arm_b_path), + "C": _identity("C", candidate)} + + binding_ok, binding_problem = check_binding(frozen["A"].sha256, binding) + + # The outcome preflight runs only once the arms are the arms: verifying a + # binary that failed its binding check would answer a question nobody asked. + outcome = (outcome_preflight(frozen, binding) if binding_ok and not failed + else OutcomePreflight(arms={}, ran=False)) + + return Prepared(binding=binding, build=built, checks=checks, preflight_failed=failed, + frozen=frozen, binding_ok=binding_ok, binding_problem=binding_problem, + arm_c_mapped_bytes=arm_c.mapped_bytes, outcome=outcome) + + +# --- the clock, reachable from exactly one place ----------------------------- + + +def time_half(harness: object, half: sch.Half, argv: list[str], env: dict[str, str], + cwd: Path, repetitions: int, discards: int) -> dict[str, object]: + """The ONLY function in this round that starts a clock. + + Routed through the instrument's own `Harness._run_once`, so the measured + interval is the instrument's and not a re-implementation that happens to + look similar. Plan mode never reaches this function, and a control counts + the calls rather than taking that on faith. + + EVERY spawn is checked against its arm's exit code, warmup discards + included. Calling `_run_once` directly is what let this round skip the + instrument's own outcome layer — the layer that exists because twelve cells + once timed `command-not-found` accurately, reproducibly, and to no purpose. + A discarded iteration that failed is still evidence the process is broken, + so it is checked even though its numbers are thrown away. + + Only the exit code is read here. Capturing stdout inside a measured interval + would change what the interval measures, which is exactly why the rich + output contract runs once, untimed, in `outcome_preflight`. + """ + run_once = harness._run_once # type: ignore[attr-defined] + expected = EXPECTED_RC[half.arm] + + def _check(row: dict[str, object], spawn_kind: str, index: int) -> dict[str, object]: + if int(row["rc"]) != expected: # type: ignore[call-overload] + # Immediately. Finishing the half after a known breach would spawn + # more processes to produce numbers nobody is allowed to use. + raise OutcomeContractBreach( + {"block": f"{half.regime}|n{half.n}|s{half.session}", "arm": half.arm, + "half": half.half, "spawn_kind": spawn_kind, "index": index, + "observed_rc": row["rc"], "expected_rc": expected}) + return row + + for i in range(discards): + _check(run_once(argv, env, cwd), "warmup", i) + samples = [_check(run_once(argv, env, cwd), "sample", i) for i in range(repetitions)] + return {"half": half.key, "expected_rc": expected, "samples": samples} + + +# --- the pass ---------------------------------------------------------------- + + +def _invalid(base: dict[str, object], exc: ExecutionContractBreach) -> dict[str, object]: + """Turn a refusal into a durable record. The black box, not just the crash. + + An exception that escapes to a traceback proves the runner refused and + leaves nothing behind to say so: no file, no abort, nothing to investigate + at 3am. That is the same shape as a control that dies before reporting, + which this project keeps rediscovering — here with the measurement runner + itself playing the part. + """ + return {**base, "run_valid": False, "measurements": None, + "abort": {"kind": exc.kind, "reason": str(exc), **exc.detail()}, + "verdict": f"INVALID / STOP ({exc.kind}): {exc}"} + + +def run(candidate: Path, build_dir: Path, measure: bool) -> dict[str, object]: + base: dict[str, object] = { + "tag": TAG, "mode": "measure" if measure else "plan", + "timestamp_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())} + try: + prepared = prepare(candidate, build_dir) + except ExecutionContractBreach as exc: + # Even a breach before the arms exist leaves a record. + return _invalid(base, exc) + plan = sch.plan() + spawns = sch.process_spawns(warmup_discards=WARMUP_DISCARDS) + + stop = prepared.stop_conditions + + record: dict[str, object] = { + **base, + "work_binding": prepared.binding.as_dict(), + "preflight": {"checks": prepared.checks, "failed": prepared.preflight_failed}, + "outcome_preflight": prepared.outcome.as_dict(), + "frozen_arms": {r: i.as_dict() for r, i in prepared.frozen.items()}, + "schedule": plan, + "planned_process_spawns": spawns, + "stop_conditions": stop, + } + + if stop: + record["verdict"] = "STOP: " + "; ".join(stop) + record["measurements"] = None + record["run_valid"] = False + return record + + if not measure: + # The return is the enforcement. Plan mode does not step over a timing + # loop guarded by a flag — it never reaches one. + record["verdict"] = ( + "PLAN ONLY. Arms built, B1-B4 passed on these exact bytes, identities " + "frozen, execution order fixed. No clock was started and none is " + "authorised: the calibration pass is a separate decision.") + record["measurements"] = None + record["run_valid"] = True + return record + + # The one boundary. Whichever contract breaks — a stray exit code, an arm + # whose bytes moved — the run ends INVALID and says so in a file. + partial: list[dict[str, object]] = [] + order: list[str] = [] + try: + record.update(_measure(prepared, candidate, partial, order)) + record["run_valid"] = True + except ExecutionContractBreach as exc: + record = _invalid(record, exc) + record["partial_measurements"] = { + "not_evidence": True, + "why_not_evidence": "the run was refused before it finished; these halves " + "are kept for investigation and must never be read as " + "data, classified, or compared against anything", + "halves_completed": len(partial), + "actual_order": order, + "halves": partial, + } + return record + + +def _measure(prepared: Prepared, candidate: Path, results: list[dict[str, object]], + actual_order: list[str]) -> dict[str, object]: + """The timing pass. Identity is re-verified before every block and after the last.""" + import perf_baseline as pb + + frozen = prepared.frozen + + harness = pb.Harness( + gate=pb.IdentityGate.load(pb.load_manifest()[1]), + session=pb.SessionIdentity.freeze(candidate), rss=pb.RssProbe(), + tmp=Path(str(prepared.build["arm_a"])).parent, + candidate=candidate, warmup_discards=WARMUP_DISCARDS, repetitions=0, seed=0) + + # The SAME argv the untimed preflight verified. Two definitions would mean + # the probe checked one command line and the clock measured another. + argv_for = {r: _argv_for(r, frozen, prepared.binding) for r in ("A", "B", "C")} + env = measurement_env() + + for block in sch.blocks(): + verify_identities(frozen, f"before block {block.key}") + discards = WARMUP_DISCARDS if block.regime == "warm" else 0 + for half in block.halves: + actual_order.append(half.key) + results.append(time_half(harness, half, argv_for[half.arm], env, ROOT, + block.n, discards)) + verify_identities(frozen, "after the last block") + + return {"measurements": results, "actual_order": actual_order, + "verdict": f"{len(results)} halves measured in the preregistered order"} + + +def main() -> int: + ap = argparse.ArgumentParser(description="Round 7 measurement runner") + ap.add_argument("--candidate", required=True, type=Path) + ap.add_argument("--out", type=Path) + ap.add_argument("--build-dir", type=Path, default=Path("round7-arms")) + mode = ap.add_mutually_exclusive_group() + mode.add_argument("--plan", action="store_true", default=True, + help="build, preflight, freeze, schedule — and stop (default)") + mode.add_argument("--measure", action="store_true", + help="run the calibration pass; a SEPARATE authorisation") + args = ap.parse_args() + + record = run(args.candidate.resolve(), args.build_dir, measure=args.measure) + blob = json.dumps(record, indent=2) + # Written on every path, refusals included. A runner that only produces a + # file when it succeeds has no way to tell anyone why it did not. + if args.out: + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(blob + "\n", encoding="utf-8") + print(f"wrote {args.out}") + print(record["verdict"]) + else: + print(blob) + return 0 if record.get("run_valid") and not record.get("stop_conditions") else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/round7/schedule.py b/scripts/round7/schedule.py new file mode 100644 index 00000000..b095c61b --- /dev/null +++ b/scripts/round7/schedule.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 +"""Round 7's execution schedule — CALIBRATION_ONLY, and pure. + +Round 7 compares three arms. The preregistration fixed how many sessions and +halves, and said nothing about ORDER, which is a hole big enough to drive the +whole result through: run every A, then every B, then every C, and a machine +that drifts over an hour hands back a beautiful "effect of the real binary". +After several pages spent fighting environmental variation, that would be a +particularly embarrassing way to lose. + +The ratified schedule, fixed here before any measurement exists: + + block = (regime, n, session_index) 40 blocks = 2 x 2 x 10 + within a block: all three arms run, each arm's two halves ADJACENT, + arm order deterministically shuffled + across blocks: block order deterministically shuffled + seed: fixed and committed before measurement + recorded: seed, planned order, actual order + +Blocked randomisation, not a Latin square. Drift is spread across arms instead +of aligning with them, and every block still contains all three arms, so a +within-block comparison is never a comparison across an hour of machine time. + +No clock here, no files, no I/O: a schedule is arithmetic on a seed, and it can +be checked exhaustively before anything is measured. +""" + +from __future__ import annotations + +import hashlib +import random +from dataclasses import dataclass + +ARMS = ("A", "B", "C") +HALVES = ("first", "second") +REGIMES = ("process-cold", "warm") +REPETITION_COUNTS = (5, 15) +SESSIONS = 10 + +# The seed is the first 16 hex digits of the Round 6 helper's sha256, as +# recorded in docs/evidence/round6/p022-263a-round6-scales.linux.json months of +# review before this round existed. +# +# A literal I invented would be just as deterministic and strictly less +# auditable: nothing but my word would stop me re-rolling it until the printed +# order looked tidy. This value was fixed by a compiler in a previous round and +# I cannot move it. `round7-schedule` checks the two against each other rather +# than trusting this comment. +SCHEDULE_SEED = 0xF937B36BD4DAC422 +SCHEDULE_SEED_SOURCE = ("first 16 hex digits of helper_sha256 in " + "docs/evidence/round6/p022-263a-round6-scales.linux.json") + + +@dataclass(frozen=True) +class Half: + """One measured half: an arm's first or second run inside one block.""" + + regime: str + n: int + session: int + arm: str + half: str + + @property + def key(self) -> str: + return f"{self.regime}|n{self.n}|s{self.session}|{self.arm}|{self.half}" + + +@dataclass(frozen=True) +class Block: + """One (regime, n, session): all three arms, each arm's halves adjacent.""" + + regime: str + n: int + session: int + arm_order: tuple[str, ...] + + @property + def key(self) -> str: + return f"{self.regime}|n{self.n}|s{self.session}" + + @property + def halves(self) -> tuple[Half, ...]: + return tuple(Half(self.regime, self.n, self.session, arm, half) + for arm in self.arm_order for half in HALVES) + + +def _block_seed(seed: int, regime: str, n: int, session: int) -> int: + """A block's own seed, derived from its identity rather than its position. + + Shuffling arms with one running generator would make a block's arm order + depend on where the block landed in the outer shuffle, so a change to the + block order would silently reshuffle every arm order too. Deriving from the + block's identity keeps the two independent and each reproducible on its own. + """ + material = f"{seed:x}|{regime}|{n}|{session}".encode() + return int.from_bytes(hashlib.sha256(material).digest()[:8], "big") + + +def blocks(seed: int = SCHEDULE_SEED) -> tuple[Block, ...]: + """The 40 blocks in execution order, arms shuffled within each.""" + out = [] + for regime in REGIMES: + for n in REPETITION_COUNTS: + for session in range(1, SESSIONS + 1): + arms = list(ARMS) + random.Random(_block_seed(seed, regime, n, session)).shuffle(arms) + out.append(Block(regime, n, session, tuple(arms))) + random.Random(seed).shuffle(out) + return tuple(out) + + +def planned_halves(seed: int = SCHEDULE_SEED) -> tuple[Half, ...]: + """Every half in the order it will be executed. 40 blocks x 6 = 240.""" + return tuple(h for b in blocks(seed) for h in b.halves) + + +def plan(seed: int = SCHEDULE_SEED) -> dict[str, object]: + """The schedule as a recordable object, seed included. + + The seed travels with the plan because a randomisation nobody can replay is + a fond memory rather than a method — the same reason the instrument records + its own interleave order. + """ + bs = blocks(seed) + return { + "seed": f"0x{seed:016x}", + "seed_source": SCHEDULE_SEED_SOURCE, + "design": "blocked randomisation; block = (regime, n, session)", + "blocks": len(bs), + "halves": len(bs) * len(ARMS) * len(HALVES), + "regimes": list(REGIMES), + "repetition_counts": list(REPETITION_COUNTS), + "sessions_per_cell": SESSIONS, + "planned_order": [{"block": b.key, "arm_order": list(b.arm_order)} for b in bs], + "tag": "CALIBRATION_ONLY", + } + + +def process_spawns(seed: int = SCHEDULE_SEED, warmup_discards: int = 2) -> int: + """How many child processes the whole round will spawn, from the plan itself. + + Derived rather than asserted, because the preregistration quotes a number + and a quoted number that nothing computes is a number that drifts. + """ + total = 0 + for b in blocks(seed): + per_half = b.n + (warmup_discards if b.regime == "warm" else 0) + total += per_half * len(ARMS) * len(HALVES) + return total diff --git a/scripts/step7/envcapture.py b/scripts/step7/envcapture.py new file mode 100644 index 00000000..e4c7b733 --- /dev/null +++ b/scripts/step7/envcapture.py @@ -0,0 +1,540 @@ +#!/usr/bin/env python3 +"""#263-A step 7 — the measurement-free environment identity manifest. + +Step 7 may not start a clock until two dedicated measurement environments exist +and the execution binding is frozen against them. This module produces the input +to that binding: one manifest per host, recording WHAT the machine is, and +nothing about how fast it is. + +It therefore contains **no clock and no resource observation**. There is no +`perf_counter`, no `monotonic`, no `wait4`, no `getrusage`, no timing of the +subprocesses it uses to read tool versions. `memory_bytes` is how much RAM the +machine HAS, never how much anything used. + +It is deliberately **self-contained**: it does not import `perf_baseline`. If it +did, "this file starts no clock" would stop being provable by reading this file, +and the audit would have to follow an import into the instrument that exists to +start clocks. Independence is the point, not duplication for its own sake. + +Two field classes, and the split is the owner's ruling rather than a convenience: + + IDENTITY what makes two runs the same measurement environment. Any change + after the first measurement invalidates that stratum. + PROVENANCE runner name, workflow and job ids, timestamp, CI flag. Recorded + faithfully, never identity. A new runner allocation is not a new + machine, and `RUNNER_NAME` changing is not environment drift. + +Every identity field is one of exactly two shapes, so "unknown" can never arrive +disguised as a value: + + {"status": "observed", "value": } + {"status": "unavailable", "reason": } + +An empty string, a zero, a bare boolean, a missing key and a silent absence are +all refused. That distinction is the whole reason this file has a schema at all. + +A caveat recorded rather than papered over: `host_fingerprint` hashes the +running system's machine id. Inside a container that is the CONTAINER's identity, +not the host's, which is one more reason the collection runs on a dedicated +machine rather than in CI. The manifest records `ci` and `runner_name` in +provenance so a manifest taken on a hosted runner cannot later pass itself off +as one taken on a measurement host. + +Usage: + python scripts/step7/envcapture.py --environment-id --emit + python scripts/step7/envcapture.py --selftest +""" + +from __future__ import annotations + +import argparse +import datetime +import hashlib +import json +import os +import platform +import subprocess +import sys +from collections.abc import Mapping +from pathlib import Path + +SCHEMA = "p022-263a-step7-environment-identity" + +# Identity-bearing. Ordered; the manifest is written in this order and the order +# is part of the schema so a reordered file is a changed file. +IDENTITY_FIELDS: tuple[str, ...] = ( + "environment_id", + "host_fingerprint", + "os_build", + "kernel", + "cpu_model", + "logical_cpu_count", + "memory_bytes", + "virtualization", + "power_policy", + "python", + "rustc", + "dotnet", +) + +# Provenance only. Present in every manifest, never compared for drift. +PROVENANCE_FIELDS: tuple[str, ...] = ( + "timestamp_utc", + "runner_name", + "workflow_run_id", + "job_id", + "ci", +) + +OBSERVED = "observed" +UNAVAILABLE = "unavailable" + +# environment_id is assigned by the owner, not discovered. Its absence is an +# operator error, never an unobservable property of the machine, so it is the +# one field for which `unavailable` is itself a refusal. +ASSIGNED_FIELDS: frozenset[str] = frozenset({"environment_id"}) + + +class CaptureRefused(Exception): + """Raised by name. A caller that reads through gets an exception, not a manifest.""" + + +def observed(value: object) -> dict[str, object]: + return {"status": OBSERVED, "value": value} + + +def unavailable(reason: str) -> dict[str, object]: + return {"status": UNAVAILABLE, "reason": reason} + + +# --- reading the machine, never timing it ---------------------------------- + + +def _text(path: str) -> str | None: + try: + return Path(path).read_text(encoding="utf-8", errors="replace") + except OSError: + return None + + +def _tool(argv: list[str]) -> tuple[int, str] | None: + """Run a version query. NOT timed, and no shell. + + Returns (returncode, stdout+stderr) or None when the tool is absent. The + return code is handed back because `systemd-detect-virt` reports "none" with + a non-zero exit, and reading that as a failure would turn a real answer into + an unavailable. + """ + try: + proc = subprocess.run(argv, capture_output=True, text=True, check=False) + except (OSError, ValueError): + return None + return proc.returncode, (proc.stdout + proc.stderr).strip() + + +def _host_fingerprint() -> dict[str, object]: + for path in ("/etc/machine-id", "/var/lib/dbus/machine-id"): + raw = _text(path) + if raw and raw.strip(): + digest = hashlib.sha256(raw.strip().encode("utf-8")).hexdigest() + return observed(f"sha256:{digest}") + if os.name == "nt": + found = _windows_machine_guid() + if found: + digest = hashlib.sha256(found.encode("utf-8")).hexdigest() + return observed(f"sha256:{digest}") + return unavailable("HKLM\\SOFTWARE\\Microsoft\\Cryptography\\MachineGuid unreadable") + return unavailable("no /etc/machine-id, no /var/lib/dbus/machine-id, not Windows") + + +def _windows_machine_guid() -> str | None: + if os.name != "nt": + return None + try: + import winreg # Windows-only; imported where it exists + except ImportError: + return None + try: + # winreg exists only on Windows, so the Linux stubs carry none of these + # names. Ignored per-attribute with the reason, not by silencing the file. + key = winreg.OpenKey( # type: ignore[attr-defined] # Windows-only stub + winreg.HKEY_LOCAL_MACHINE, # type: ignore[attr-defined] # Windows-only stub + r"SOFTWARE\Microsoft\Cryptography") + with key: + value, _kind = winreg.QueryValueEx( # type: ignore[attr-defined] # Windows-only + key, "MachineGuid") + except OSError: + return None + return str(value) if value else None + + +def _windows_cim(class_name: str, props: tuple[str, ...]) -> dict[str, str] | None: + """One CIM query for identity. No shell, no timing, no clock. + + `wmic` is gone from recent Windows images — the first CI run of this tool on + windows-latest (Server 2025) fell straight through it — so the model name + arrived as `platform.processor()`'s family/model/stepping string instead of + the processor's actual name. CIM is the supported replacement. + """ + if os.name != "nt": + return None + script = "; ".join( + [f"$o = Get-CimInstance -ClassName {class_name} | Select-Object -First 1"] + + [f"Write-Output ('{prop}=' + $o.{prop})" for prop in props]) + for exe in ("powershell", "pwsh"): + found = _tool([exe, "-NoProfile", "-NonInteractive", "-Command", script]) + if found is None or found[0] != 0: + continue + values: dict[str, str] = {} + for line in found[1].splitlines(): + key, _, value = line.partition("=") + if key.strip() in props and value.strip(): + values[key.strip()] = value.strip() + if values: + return values + return None + + +def _os_build() -> dict[str, object]: + if os.name == "nt": + release, version, csd, ptype = platform.win32_ver() + parts = [p for p in (release, version, csd, ptype) if p] + if parts: + return observed("Windows " + " ".join(parts)) + return unavailable("platform.win32_ver() returned nothing") + raw = _text("/etc/os-release") + if raw: + fields: dict[str, str] = {} + for line in raw.splitlines(): + if "=" in line: + key, _, val = line.partition("=") + fields[key.strip()] = val.strip().strip('"') + name = fields.get("PRETTY_NAME") or fields.get("NAME") + build = fields.get("VERSION_ID") or fields.get("BUILD_ID") + if name: + return observed(f"{name} (VERSION_ID={build})" if build else name) + system = platform.system() + if system: + return observed(system) + return unavailable("no /etc/os-release and platform.system() is empty") + + +def _kernel() -> dict[str, object]: + release, version = platform.release(), platform.version() + if release or version: + return observed(f"{release} {version}".strip()) + return unavailable("platform.release() and platform.version() are both empty") + + +def _cpu_model() -> dict[str, object]: + raw = _text("/proc/cpuinfo") + if raw: + for line in raw.splitlines(): + if line.lower().startswith("model name"): + _, _, value = line.partition(":") + if value.strip(): + return observed(value.strip()) + if os.name == "nt": + cim = _windows_cim("Win32_Processor", ("Name",)) + if cim and cim.get("Name"): + return observed(cim["Name"]) + processor = platform.processor() + if processor: + return observed(processor) + if os.name == "nt": + return unavailable("no Win32_Processor Name through powershell or pwsh, and " + "platform.processor() is empty") + return unavailable("no model name in /proc/cpuinfo and platform.processor() is empty") + + +def _logical_cpu_count() -> dict[str, object]: + count = os.cpu_count() + if isinstance(count, int) and count > 0: + return observed(count) + return unavailable("os.cpu_count() returned no usable count") + + +def _memory_bytes() -> dict[str, object]: + """Installed RAM. NOT a usage measurement; nothing here observes consumption.""" + raw = _text("/proc/meminfo") + if raw: + for line in raw.splitlines(): + if line.startswith("MemTotal:"): + parts = line.split() + if len(parts) >= 2 and parts[1].isdigit(): + return observed(int(parts[1]) * 1024) + if os.name == "nt": + total = _windows_total_ram() + if total: + return observed(total) + return unavailable("GlobalMemoryStatusEx did not report a total") + return unavailable("no MemTotal in /proc/meminfo and not Windows") + + +def _windows_total_ram() -> int | None: + if os.name != "nt": + return None + import ctypes # only needed on the Windows path + + class _Status(ctypes.Structure): + _fields_ = [("dwLength", ctypes.c_ulong), ("dwMemoryLoad", ctypes.c_ulong), + ("ullTotalPhys", ctypes.c_ulonglong), ("ullAvailPhys", ctypes.c_ulonglong), + ("ullTotalPageFile", ctypes.c_ulonglong), + ("ullAvailPageFile", ctypes.c_ulonglong), + ("ullTotalVirtual", ctypes.c_ulonglong), + ("ullAvailVirtual", ctypes.c_ulonglong), + ("ullAvailExtendedVirtual", ctypes.c_ulonglong)] + + status = _Status() + status.dwLength = ctypes.sizeof(_Status) + try: + # ctypes.windll is defined only on Windows; same treatment as above. + kernel32 = ctypes.windll.kernel32 # type: ignore[attr-defined] # Windows-only + if not kernel32.GlobalMemoryStatusEx(ctypes.byref(status)): + return None + except (AttributeError, OSError): + return None + return int(status.ullTotalPhys) or None + + +def _virtualization() -> dict[str, object]: + """Exact, or explicitly classified. Never a guessed 'probably bare metal'. + + Platform-branched, because an `unavailable` reason that names the other + platform's mechanisms is a false statement about what was tried. The first + Windows CI run of this tool reported "systemd-detect-virt absent ... no DMI + identity under /sys" on Windows Server 2025, which is true of every Windows + machine ever built and told the reader nothing. + """ + if os.name == "nt": + cim = _windows_cim("Win32_ComputerSystem", ("Manufacturer", "Model")) + if cim: + return observed(f"Win32_ComputerSystem Manufacturer={cim.get('Manufacturer', '?')} " + f"Model={cim.get('Model', '?')}") + return unavailable("Win32_ComputerSystem is unreadable through powershell and pwsh, " + "so the virtualization boundary is not classified on this host") + found = _tool(["systemd-detect-virt"]) + if found is not None: + # Exit 1 with "none" is the tool answering, not failing. + answer = found[1].strip() + if answer and "\n" not in answer: + return observed(answer) + vendor = (_text("/sys/class/dmi/id/sys_vendor") or "").strip() + product = (_text("/sys/class/dmi/id/product_name") or "").strip() + if vendor or product: + return observed(f"dmi sys_vendor={vendor or '?'} product_name={product or '?'}") + return unavailable("systemd-detect-virt absent or unclear and no DMI identity under /sys") + + +def _power_policy() -> dict[str, object]: + if os.name == "nt": + found = _tool(["powercfg", "/getactivescheme"]) + if found and found[0] == 0 and found[1].strip(): + return observed(found[1].strip()) + return unavailable("powercfg /getactivescheme produced no active scheme") + governor = _text("/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor") + if governor and governor.strip(): + return observed(f"cpufreq scaling_governor={governor.strip()}") + return unavailable( + "no /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor on this host; CPU " + "frequency policy is not observable here") + + +def _python() -> dict[str, object]: + return observed(f"{platform.python_implementation()} " + f"{sys.version.replace(chr(10), ' ').strip()}") + + +def _version_of(name: str, argv: list[str]) -> dict[str, object]: + found = _tool(argv) + if found is None: + return unavailable(f"{name} is not on PATH") + code, text = found + if code != 0 or not text: + return unavailable(f"{' '.join(argv)} exited {code} without a version") + return observed("; ".join(line.strip() for line in text.splitlines() if line.strip())) + + +# --- the manifest ----------------------------------------------------------- + + +def _refuse_drift(what: str, declared: tuple[str, ...], collected: Mapping[str, object]) -> None: + """A declared field with no collector is a schema that lies about itself.""" + missing = [name for name in declared if name not in collected] + extra = [name for name in collected if name not in declared] + if missing or extra: + raise CaptureRefused( + f"{what}: the declared schema and the collected fields disagree — " + f"declared with no collector: {missing or 'none'}; " + f"collected but undeclared: {extra or 'none'}") + + +def capture(environment_id: str) -> dict[str, object]: + """Build one host's manifest. Starts no clock and observes no resource use.""" + if not isinstance(environment_id, str) or not environment_id.strip(): + raise CaptureRefused( + "environment_id is assigned by the owner and must be a non-empty string; " + "it is not discoverable, so there is nothing to fall back to") + identity: dict[str, object] = { + "environment_id": observed(environment_id.strip()), + "host_fingerprint": _host_fingerprint(), + "os_build": _os_build(), + "kernel": _kernel(), + "cpu_model": _cpu_model(), + "logical_cpu_count": _logical_cpu_count(), + "memory_bytes": _memory_bytes(), + "virtualization": _virtualization(), + "power_policy": _power_policy(), + "python": _python(), + "rustc": _version_of("rustc", ["rustc", "--version", "--verbose"]), + "dotnet": _version_of("dotnet", ["dotnet", "--version"]), + } + # The declared schema and the collectors above can drift apart. Projecting one + # through the other would then die with a KeyError, which is a traceback rather + # than a refusal, so the mismatch is named instead. + _refuse_drift("identity", IDENTITY_FIELDS, identity) + + stamp = datetime.datetime.now(datetime.UTC).replace(microsecond=0).isoformat() + provenance: dict[str, object] = { + "timestamp_utc": stamp, + "runner_name": os.environ.get("RUNNER_NAME") or None, + "workflow_run_id": os.environ.get("GITHUB_RUN_ID") or None, + "job_id": os.environ.get("GITHUB_JOB") or None, + "ci": bool(os.environ.get("CI")), + } + _refuse_drift("provenance", PROVENANCE_FIELDS, provenance) + return { + "schema": SCHEMA, + "measurement_free": True, + "identity": {k: identity[k] for k in IDENTITY_FIELDS}, + "provenance": {k: provenance[k] for k in PROVENANCE_FIELDS}, + "note": ("identity fields decide whether two runs share one measurement " + "environment; provenance fields never do. This manifest contains no " + "timing and no resource observation."), + } + + +def field_problems(name: str, field: object) -> list[str]: + """The two-shape contract, checked rather than described.""" + if not isinstance(field, Mapping): + return [f"{name}: expected an object with a status, got {type(field).__name__}"] + status = field.get("status") + if status == OBSERVED: + problems = [] + if "reason" in field: + problems.append(f"{name}: observed fields carry no reason") + if "value" not in field: + problems.append(f"{name}: observed with no value") + return problems + value = field["value"] + # bool IS an int in Python, so an unchecked numeric test would accept True. + if isinstance(value, bool): + problems.append(f"{name}: a boolean is not an identity value") + elif isinstance(value, str) and not value.strip(): + problems.append(f"{name}: observed with an empty string, which is not an observation") + elif isinstance(value, int) and value <= 0: + problems.append(f"{name}: observed with {value}, and zero is not a measurement") + elif value is None: + problems.append(f"{name}: observed with null; absence is 'unavailable' with a reason") + elif not isinstance(value, str | int): + problems.append(f"{name}: value is {type(value).__name__}, not a string or a count") + return problems + if status == UNAVAILABLE: + if name in ASSIGNED_FIELDS: + return [f"{name}: assigned by the owner, so it can never be unavailable"] + reason = field.get("reason") + if "value" in field: + return [f"{name}: unavailable fields carry no value"] + if not isinstance(reason, str) or not reason.strip(): + return [f"{name}: unavailable with no stated reason"] + return [] + return [f"{name}: status {status!r} is neither {OBSERVED!r} nor {UNAVAILABLE!r}"] + + +def validate(manifest: object) -> list[str]: + """Pure. Returns every problem, so one fixture reports all of them at once.""" + if not isinstance(manifest, Mapping): + return [f"manifest: expected an object, got {type(manifest).__name__}"] + problems: list[str] = [] + if manifest.get("schema") != SCHEMA: + problems.append(f"schema: expected {SCHEMA!r}, got {manifest.get('schema')!r}") + identity = manifest.get("identity") + provenance = manifest.get("provenance") + if not isinstance(identity, Mapping): + problems.append("identity: missing or not an object") + else: + for name in IDENTITY_FIELDS: + if name not in identity: + problems.append(f"identity.{name}: missing; a silent absence is not 'unavailable'") + else: + problems.extend(field_problems(f"identity.{name}", identity[name])) + for name in identity: + if name not in IDENTITY_FIELDS: + problems.append(f"identity.{name}: not a declared identity field") + if not isinstance(provenance, Mapping): + problems.append("provenance: missing or not an object") + else: + for name in PROVENANCE_FIELDS: + if name not in provenance: + problems.append(f"provenance.{name}: missing") + for name in provenance: + if name not in PROVENANCE_FIELDS: + problems.append(f"provenance.{name}: not a declared provenance field") + elif name in IDENTITY_FIELDS: + problems.append(f"provenance.{name}: is an identity field and must not be here") + return problems + + +def identity_drift(earlier: Mapping[str, object], later: Mapping[str, object]) -> tuple[str, ...]: + """Identity fields that differ. Provenance is never consulted. + + A field compares whole: a status that moved from observed to unavailable, or + a reason that changed, is drift. Reading only `value` would let a field go + dark between runs without anyone noticing. + """ + a, b = earlier.get("identity"), later.get("identity") + if not isinstance(a, Mapping) or not isinstance(b, Mapping): + raise CaptureRefused("both manifests must carry an identity object to be compared") + return tuple(name for name in IDENTITY_FIELDS if a.get(name) != b.get(name)) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__, add_help=True) + parser.add_argument("--environment-id", help="owner-assigned stable identifier") + parser.add_argument("--emit", type=Path, help="write the manifest here") + parser.add_argument("--selftest", action="store_true", + help="capture this host and validate it, writing nothing") + args = parser.parse_args(argv) + + if args.selftest: + manifest = capture("selftest-not-a-measurement-environment") + problems = validate(manifest) + for problem in problems: + print(f"FAIL: {problem}") + print(json.dumps({"identity": manifest["identity"]}, indent=2, sort_keys=False)) + return 1 if problems else 0 + + if not args.environment_id: + print("refused: --environment-id is required and is assigned by the owner", file=sys.stderr) + return 2 + try: + manifest = capture(args.environment_id) + except CaptureRefused as exc: + print(f"refused: {exc}", file=sys.stderr) + return 2 + problems = validate(manifest) + for problem in problems: + print(f"FAIL: {problem}", file=sys.stderr) + if problems: + return 1 + text = json.dumps(manifest, indent=2, sort_keys=False) + "\n" + if args.emit: + args.emit.write_text(text, encoding="utf-8") + print(f"wrote {args.emit}") + else: + print(text, end="") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/training/scope.py b/scripts/training/scope.py new file mode 100644 index 00000000..e35a0ddf --- /dev/null +++ b/scripts/training/scope.py @@ -0,0 +1,139 @@ +"""#263-A calibration — the cross-platform training scope combiner (step 6). + +Platform is an **outer training stratum**, never a fifth cell axis. The frozen +four-part cell identity `(rung, engine, workload, regime)` is unchanged, cold and +warm remain distinct cells that pool within a stratum, and observations, medians, +envelopes and widths are **never** pooled or summed across strata. + +This module exists because that rule is code which takes a statistical decision, +and §3.6 of the ratified policy requires such code to exist and be +provenance-bound *before* any training data does. It lives outside +`scripts/calibration/` on purpose: the step 4 freeze proves that the frozen root +grew no new file, and it would stop proving that if this landed inside it. + +It implements exactly two things the frozen policy cannot express: + + Q_p the rungs admissible on one stratum + Q_common their intersection, and the single selected N + +**It does not re-implement the `(1 + G)` admissibility test.** The frozen +`select_n` already computes that and reports `widths` and `limit` alongside its +own pick; `Q_p` is read back off those. A second copy of the margin arithmetic +here would prove only that the two copies agree, which is the defect this PR has +spent thirteen rounds removing. The margin is applied once, inside frozen code. + +No clock, no filesystem, no network, no randomness, no numeric default, and no +constant value of any kind: `G` and the ladder arrive in `DesignConstants`. +""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from fractions import Fraction + +import policy as pol + +OUTCOME_SELECTED = "SELECTED" +OUTCOME_NO_COMMON_N = "NO_COMMON_N" + + +class ScopeRefused(Exception): + """Raised rather than returning something that would be read as a result.""" + + +def _exact_from_pair(value: object, *, name: str) -> Fraction: + """Rebuild an exact rational from the frozen policy's own reduced pair. + + `canonical_rational` does the checking, so the reduced-pair contract has one + implementation and this module is not a second opinion about what exact means. + """ + if isinstance(value, (str, bytes)) or not isinstance(value, Sequence) or len(value) != 2: + raise ScopeRefused( + f"{name} is {value!r}; the frozen select_n reports every width as a reduced " + "(numerator, denominator) pair, and a scope decision is taken on nothing else") + return pol.canonical_rational(value[0], value[1], name=name) + + +def admissible_rungs(selection: Mapping[str, object], constants: pol.DesignConstants, + *, stratum: str) -> tuple[int, ...]: + """`Q_p`: every ladder rung within `(1 + G)` of THIS stratum's own best width. + + Read off the frozen `select_n` result rather than recomputed. `limit` is that + function's own `(1 + G) * best`, so the margin cannot drift between the rung + one stratum picks alone and the rungs both strata will be asked to share. + """ + widths = selection.get("widths") + if not isinstance(widths, Mapping): + raise ScopeRefused(f"{stratum}: the selection carries no widths mapping, so its " + "admissible set cannot be read off it") + limit = _exact_from_pair(selection.get("limit"), name=f"{stratum}: limit") + + admissible: list[int] = [] + for n in constants.n_ladder: + if n not in widths: + raise ScopeRefused( + f"{stratum}: no width for ladder rung n={n}; a stratum missing a rung " + "cannot be intersected, because a rung that was never measured is not " + "the same as a rung that was measured and excluded") + if _exact_from_pair(widths[n], name=f"{stratum}: width at n={n}") <= limit: + admissible.append(n) + + if not admissible: + raise ScopeRefused( + f"{stratum}: no rung is within (1 + G) of its own best width. That is " + "impossible for G >= 0, so these are not this stratum's own widths and " + "limit") + return tuple(admissible) + + +def combine(selections: Mapping[str, Mapping[str, object]], constants: pol.DesignConstants, + *, strata: Sequence[str]) -> dict[str, object]: + """`Q_common`, and the one selected N, or a `NO_COMMON_N` stop. + + The rule is the smallest ladder rung admissible on **every** stratum. It is + deliberately not `max` of the per-stratum picks, which can name a rung that + satisfies no stratum's margin; not an averaged width, which lets an unstable + machine buy the stable one a wider bound; and not "take one platform as the + reference", which puts the other into D7 with no measurement model of its own. + + `NO_COMMON_N` is an **orchestration** outcome, not a fifth reproducibility + verdict: the frozen four describe cells and run pairs and are untouched here. + It means only that the strata admit no shared repetition count under the + preregistered rule. There is no fallback rung, no stricter-stratum tie-break, + no second `G` and no second fit. + + On `NO_COMMON_N` the result carries **no** `selected_n` key at all, so a caller + that reads it without checking the outcome raises `KeyError` instead of + proceeding on a number that does not exist. + """ + names = tuple(strata) + if len(names) < 2: + raise ScopeRefused( + f"strata is {list(names)}; a cross-stratum selection over fewer than two " + "strata is a single-stratum selection wearing the word cross") + if len(set(names)) != len(names): + raise ScopeRefused(f"strata {list(names)} names one stratum twice") + if set(names) != set(selections): + raise ScopeRefused( + f"strata {sorted(names)} and selections {sorted(selections)} are not the same " + "set; a stratum silently dropped here is a platform silently excused from " + "the intersection") + + per_stratum = {p: admissible_rungs(selections[p], constants, stratum=p) for p in names} + common = tuple(n for n in constants.n_ladder + if all(n in per_stratum[p] for p in names)) + + result: dict[str, object] = { + "outcome": OUTCOME_NO_COMMON_N if not common else OUTCOME_SELECTED, + "strata": names, + "admissible_rungs": {p: per_stratum[p] for p in names}, + "q_common": common, + } + if not common: + result["why"] = ("no ladder rung is admissible on every stratum, so the " + "preregistered rule selects nothing and step 8 stops") + return result + result["selected_n"] = common[0] + result["why"] = (f"n={common[0]} is the smallest ladder rung admissible on every " + f"stratum {list(names)}") + return result diff --git a/tests/test_calibration_constants.py b/tests/test_calibration_constants.py new file mode 100644 index 00000000..c359fc5e --- /dev/null +++ b/tests/test_calibration_constants.py @@ -0,0 +1,253 @@ +#!/usr/bin/env python3 +"""#263-A calibration policy — step 5, the ratified design constants. + +Step 5 records the five constants the owner chose, bound to the step 4 identity. +It records nothing else. No `A_abs`, no `R_rel`, no selected `N`, no measurement +output: those are empirical, they do not exist yet, and an artifact that made +room for them would be step 7 arriving with step 5's paperwork. + + constants-artifact-shape the artifact is five design constants and two bindings + constants-accepted-by-policy the frozen implementation accepts them and round-trips + constants-bound-to-freeze the bindings are the step 4 digests, not lookalikes + constants-no-empirical no name the policy uses for a fitted quantity appears + +`constants-accepted-by-policy` is the one that matters. It does not re-implement +the ranges — `0 < q < 1`, `M > 1`, `G >= 0`, `R_runs >= 2`, a strictly increasing +ladder — because a second copy of those rules would only ever prove the two copies +agree. It hands the committed pairs to the frozen `DesignConstants.from_committed()` +and lets the implementation under freeze be the judge. + +Failures print `FAIL[]: `; nothing stops at the first one. + +Run: python tests/test_calibration_constants.py +""" + +from __future__ import annotations + +import json +import sys +from fractions import Fraction +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts")) +sys.path.insert(0, str(ROOT / "scripts" / "calibration")) + +import perf_baseline as pb # noqa: E402 +import policy as pol # noqa: E402 + +CONSTANTS_ARTIFACT = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-design-constants.json" +FREEZE_ARTIFACT = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-policy-freeze.json" + +ARTIFACT_NAME = "p022-263a-calibration-design-constants" +RATIONALS = ("q", "M", "G") +COUNTS = ("R_runs",) +LADDERS = ("N_ladder",) + +_FAILURES: list[tuple[str, str]] = [] +_PASSES: list[str] = [] + + +def fail(check: str, detail: str) -> None: + _FAILURES.append((check, detail)) + print(f"FAIL[{check}]: {detail}") + + +def ok(check: str, detail: str = "") -> None: + _PASSES.append(check) + print(f"ok[{check}]: {detail}" if detail else f"ok[{check}]") + + +def _exact_int(value: object) -> bool: + """`bool` is excluded: in Python a bool IS an int, and round 9 was lost to that.""" + return isinstance(value, int) and not isinstance(value, bool) + + +def _load(path: Path, check: str) -> dict[str, object] | None: + if not path.exists(): + fail(check, f"{path.relative_to(ROOT).as_posix()} does not exist") + return None + try: + loaded = json.loads(path.read_text(encoding="utf-8")) + except (OSError, ValueError) as exc: + fail(check, f"{path.name} could not be read as JSON: {exc}") + return None + if not isinstance(loaded, dict): + fail(check, f"{path.name} is a {type(loaded).__name__}, not an object") + return None + return loaded + + +def control_artifact_shape(art: dict[str, object]) -> None: + permitted = {"artifact", "bound_measurement_harness_digest", + "bound_policy_implementation_digest", "constants", "ratified_by"} + problems: list[str] = [] + + unexpected = sorted(set(art) - permitted) + missing = sorted(permitted - set(art)) + if unexpected: + problems.append(f"keys step 5 does not permit: {unexpected}; the empirical " + "constants are fitted, not chosen, and have no home here") + if missing: + problems.append(f"keys step 5 requires: {missing}") + if art.get("artifact") != ARTIFACT_NAME: + problems.append("artifact is not the frozen literal") + if art.get("ratified_by") != "owner": + problems.append("ratified_by is not 'owner'; a constant this repository chose " + "for itself is the one thing step 5 must never record") + for key in ("bound_policy_implementation_digest", "bound_measurement_harness_digest"): + value = art.get(key) + if not (isinstance(value, str) and len(value) == 64 + and all(ch in "0123456789abcdef" for ch in value)): + problems.append(f"{key} is not 64 lowercase hex characters") + + constants = art.get("constants") + if not isinstance(constants, dict): + problems.append("constants is not an object") + else: + expected = set(RATIONALS) | set(COUNTS) | set(LADDERS) + if set(constants) != expected: + problems.append(f"constants names {sorted(constants)}, not {sorted(expected)}") + for name in RATIONALS: + pair = constants.get(name) + if not (isinstance(pair, list) and len(pair) == 2 and all(_exact_int(v) for v in pair)): + problems.append(f"{name} is not a pair of exact integers; a rational is " + "committed as a reduced pair, never as a float or a " + "decimal string") + for name in COUNTS: + if not _exact_int(constants.get(name)): + problems.append(f"{name} is not an exact integer count") + for name in LADDERS: + ladder = constants.get(name) + if not (isinstance(ladder, list) and ladder and all(_exact_int(v) for v in ladder)): + problems.append(f"{name} is not a non-empty list of exact integers") + + if problems: + fail("constants-artifact-shape", "; ".join(problems)) + else: + ok("constants-artifact-shape", + f"{len(permitted)} permitted keys and no others; {len(RATIONALS)} rationals as " + f"reduced pairs, {len(COUNTS)} count and {len(LADDERS)} ladder as exact integers") + + +def control_accepted_by_policy(art: dict[str, object]) -> None: + """The frozen implementation is the judge of its own constants.""" + constants = art.get("constants") + if not isinstance(constants, dict): + fail("constants-accepted-by-policy", "there are no constants to hand to the policy") + return + try: + built = pol.DesignConstants.from_committed( + q=tuple(constants["q"]), m=tuple(constants["M"]), # type: ignore[arg-type] + r_runs=constants["R_runs"], n_ladder=constants["N_ladder"], # type: ignore[arg-type] + g=tuple(constants["G"])) # type: ignore[arg-type] + except (pol.PolicyRefused, KeyError, TypeError, ValueError) as exc: + fail("constants-accepted-by-policy", + f"the frozen policy refuses the committed constants: {exc}") + return + + round_trip = json.loads(json.dumps(built.as_committed())) + committed = json.loads(json.dumps(constants)) + if round_trip != committed: + fail("constants-accepted-by-policy", + f"the policy reads the constants back as {round_trip}, not as the committed " + f"{committed}; a form that does not survive the round trip is not canonical") + return + if not all(isinstance(v, Fraction) for v in (built.q, built.m, built.g)): + fail("constants-accepted-by-policy", "a rational came back as something other " + "than Fraction") + return + ok("constants-accepted-by-policy", + f"q={built.q}, M={built.m}, R_runs={built.r_runs}, ladder={list(built.n_ladder)} " + f"stopping at {built.n_ladder[-1]}, G={built.g}; accepted by the frozen " + "implementation and byte-identical on the round trip") + + +def control_bound_to_freeze(art: dict[str, object]) -> None: + freeze = _load(FREEZE_ARTIFACT, "constants-bound-to-freeze") + if freeze is None: + return + problems: list[str] = [] + pairs = (("bound_policy_implementation_digest", "policy_implementation_digest"), + ("bound_measurement_harness_digest", "measurement_harness_digest")) + for here, there in pairs: + if art.get(here) != freeze.get(there): + problems.append(f"{here} is {str(art.get(here))[:12]} but step 4 froze " + f"{str(freeze.get(there))[:12]}") + live = pb.harness_digest() + if art.get("bound_measurement_harness_digest") != live: + problems.append(f"the bound harness digest is not the live one, {live[:12]}") + if problems: + fail("constants-bound-to-freeze", "; ".join(problems) + + "; constants bound to an implementation other than the frozen one are " + "constants for a policy nobody reviewed") + else: + ok("constants-bound-to-freeze", + f"bound to policy {str(art.get('bound_policy_implementation_digest'))[:12]}… and " + f"harness {live[:12]}…, both equal to what step 4 froze") + + +def control_no_empirical(art: dict[str, object]) -> None: + """No name the policy itself uses for a fitted quantity may appear here. + + The exact schema above is the primary guarantee. This is a second net, and it + is DERIVED from the module rather than hand-listed: the forbidden names are + whatever `Envelope` serialises as, so if the policy ever grows another + empirical field the net grows with it instead of going quietly out of date. + + NO MUTATION ISOLATES THIS CONTROL, and that is recorded rather than papered + over. Every way of smuggling an empirical name in today is refused one check + earlier by the exact schema, so the mutation campaign scores those against + `constants-artifact-shape`. This is defence in depth, which is worth having and + is not the same thing as tested coverage. Counting it as covered would be the + defect this PR exists to remove, one level up. + """ + sample = pol.Envelope(n=1, a_abs=Fraction(0), r_rel=Fraction(0)) + empirical = set(sample.as_committed()) - {"n"} + empirical |= {"selected_N", "measurements", "elapsed_ns"} + + def names(node: object) -> list[str]: + if isinstance(node, dict): + return list(node) + [n for v in node.values() for n in names(v)] + if isinstance(node, list): + return [n for item in node for n in names(item)] + return [] + + def floats(node: object) -> list[object]: + if isinstance(node, dict): + return [f for v in node.values() for f in floats(v)] + if isinstance(node, list): + return [f for item in node for f in floats(item)] + return [node] if isinstance(node, float) else [] + + problems: list[str] = [] + present = sorted(set(names(art)) & empirical) + if present: + problems.append(f"names the policy uses for fitted quantities: {present}; those " + "are measured, not chosen, and no measurement is authorised") + stray = floats(art) + if stray: + problems.append(f"floating-point values: {stray}; the policy computes in exact " + "rationals and a committed decimal is a float to one reader and " + "a rational to another") + if problems: + fail("constants-no-empirical", "; ".join(problems)) + else: + ok("constants-no-empirical", + f"none of {sorted(empirical)} appears, and no value is a float") + + +def run() -> int: + art = _load(CONSTANTS_ARTIFACT, "constants-artifact-shape") + if art is not None: + control_artifact_shape(art) + control_accepted_by_policy(art) + control_bound_to_freeze(art) + control_no_empirical(art) + print() + print(f"calibration constants controls: {len(_PASSES)} passed, {len(_FAILURES)} failed") + return 1 if _FAILURES else 0 + + +if __name__ == "__main__": + sys.exit(run()) diff --git a/tests/test_calibration_freeze.py b/tests/test_calibration_freeze.py new file mode 100644 index 00000000..f24dacfd --- /dev/null +++ b/tests/test_calibration_freeze.py @@ -0,0 +1,488 @@ +#!/usr/bin/env python3 +"""#263-A calibration policy — the step 4 digest freeze, and its controls. + +Step 4 freezes WHICH BYTES the policy mechanism consists of. It freezes no +constant value and reads no measurement. An artifact that carried `q`, a ladder +or a fitted `A_abs` would have quietly become step 5, and step 5 is not +authorised — so `freeze-artifact-shape` enumerates the whole permitted schema +and refuses anything else, rather than listing the field names it happens to +know are forbidden today. + +The artifact lives outside `scripts/calibration/` deliberately: a freeze stored +inside the tree it freezes would change that tree by existing. + + freeze-artifact-shape the artifact is identity and nothing else + freeze-ancestry the frozen source commit is an ancestor of HEAD + freeze-source-set the recorded files are git's, at that commit + freeze-source-root-clean nothing under the policy root escapes the selector + freeze-digest the frozen digest recomputes from the blobs at S + freeze-source-unchanged the policy source has not moved since S + freeze-harness-untouched the measurement harness digest still holds + +All but the first need git history. Where it is absent they REFUSE rather than +skip, because a control that quietly verifies nothing is the defect this PR has +spent twelve rounds removing. + +Failures print `FAIL[]: `; nothing stops at the first one. + +Run: python tests/test_calibration_freeze.py +Emit: python tests/test_calibration_freeze.py --emit +""" + +from __future__ import annotations + +import hashlib +import json +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts")) + +import perf_baseline as pb # noqa: E402 + +FREEZE_ARTIFACT = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-policy-freeze.json" + +ARTIFACT_NAME = "p022-263a-calibration-policy-freeze" +POLICY_SOURCE_ROOT = "scripts/calibration/" +POLICY_SOURCE_SELECTOR = ( + "all committed *.py recursively under policy_source_root at policy_source_commit" +) + +# The framing is part of the freeze: a digest whose byte layout is described only +# in prose is a digest a second implementation cannot reproduce. +DIGEST_FRAMING = ( + "sha256 over the source set ordered by the UTF-8 bytes of each repo-relative " + "POSIX path. Each file contributes, with no header and no separator: its path " + "byte length as an 8-byte big-endian unsigned integer, its path's exact UTF-8 " + "bytes, its blob byte length as an 8-byte big-endian unsigned integer, and its " + "exact git blob bytes." +) + +_FAILURES: list[tuple[str, str]] = [] +_PASSES: list[str] = [] + + +def fail(check: str, detail: str) -> None: + _FAILURES.append((check, detail)) + print(f"FAIL[{check}]: {detail}") + + +def ok(check: str, detail: str = "") -> None: + _PASSES.append(check) + print(f"ok[{check}]: {detail}" if detail else f"ok[{check}]") + + +class FreezeRefused(Exception): + """Raised rather than returning a value that would look like a result.""" + + +# -------------------------------------------------------------------------- +# The digest formula, written ONCE. +# +# `--emit` produced the committed artifact with this function and the controls +# recompute with the same one. That is deliberate: two implementations agreeing +# would only prove the two agree. What the control actually compares is a frozen +# literal in a committed JSON against a fresh read of immutable git objects, so +# a drift in either the bytes or the formula shows up as a mismatch. +# -------------------------------------------------------------------------- + +def _u64(value: int) -> bytes: + if value < 0 or value >= 1 << 64: + raise FreezeRefused(f"length {value} does not fit an 8-byte big-endian field") + return value.to_bytes(8, "big") + + +def implementation_digest(entries: list[tuple[str, bytes]]) -> str: + """The aggregate digest over a source set of (repo-relative path, blob bytes).""" + if not entries: + raise FreezeRefused( + "the source set is empty; sha256 of nothing is a perfectly stable value " + "that proves nothing about a policy implementation") + seen = {path for path, _ in entries} + if len(seen) != len(entries): + raise FreezeRefused("the source set names the same path twice") + digest = hashlib.sha256() + for path, blob in sorted(entries, key=lambda entry: entry[0].encode("utf-8")): + path_bytes = path.encode("utf-8") + digest.update(_u64(len(path_bytes))) + digest.update(path_bytes) + digest.update(_u64(len(blob))) + digest.update(blob) + return digest.hexdigest() + + +# -------------------------------------------------------------------------- +# git, refusing rather than degrading +# -------------------------------------------------------------------------- + +def _git(*args: str) -> tuple[int, bytes]: + proc = subprocess.run(["git", "-C", str(ROOT), *args], capture_output=True) + return proc.returncode, proc.stdout + + +def is_shallow() -> bool: + rc, out = _git("rev-parse", "--is-shallow-repository") + return rc == 0 and out.decode().strip() == "true" + + +def require_objects(commit: str) -> None: + """Refuse unless this checkout really holds what the claim is about. + + The first draft of this refused on shallowness alone, which is a proxy: a + shallow clone can still hold the commit in question, and this one does. What + every check below actually needs is the objects, so that is what is read. The + one claim shallowness genuinely blocks is ancestry, and that is handled where + it arises rather than by refusing everything in advance. + """ + for spec, what in ((f"{commit}^{{commit}}", "commit"), (f"{commit}^{{tree}}", "tree")): + if _git("cat-file", "-e", spec)[0] != 0: + raise FreezeRefused( + f"the {what} object for {commit[:12]} is not in this checkout, so no " + "claim about its contents can be tested here" + + ("; the history is truncated, and the job needs fetch-depth: 0" + if is_shallow() else "")) + + +def source_set_at(commit: str, root: str) -> list[tuple[str, str, int]]: + """(path, blob sha1, byte length) for every *.py under `root` at `commit`.""" + rc, out = _git("ls-tree", "-r", "--long", "-z", commit, "--", root) + if rc != 0: + raise FreezeRefused(f"git could not list {root} at {commit[:12]}") + return [entry for entry in _parse_ls_tree(out) if entry[0].endswith(".py")] + + +def _parse_ls_tree(out: bytes) -> list[tuple[str, str, int]]: + entries: list[tuple[str, str, int]] = [] + for record in out.decode("utf-8").split("\0"): + if not record.strip(): + continue + meta, path = record.split("\t", 1) + _mode, kind, sha, size = meta.split() + if kind != "blob": + raise FreezeRefused(f"{path} is a {kind}, and a source set is files") + entries.append((path, sha, int(size))) + return entries + + +def blob_at(sha: str) -> bytes: + rc, out = _git("cat-file", "blob", sha) + if rc != 0: + raise FreezeRefused(f"blob {sha[:12]} could not be read") + return out + + +def build_freeze(commit: str) -> dict[str, object]: + """The artifact, computed entirely from git objects at `commit`.""" + require_objects(commit) + rc, out = _git("rev-parse", f"{commit}^{{tree}}") + if rc != 0: + raise FreezeRefused(f"{commit[:12]} has no tree") + tree = out.decode().strip() + entries = source_set_at(commit, POLICY_SOURCE_ROOT) + digest = implementation_digest([(path, blob_at(sha)) for path, sha, _ in entries]) + return { + "artifact": ARTIFACT_NAME, + "measurement_harness_digest": pb.harness_digest_at(ROOT, commit) or "", + "policy_implementation_digest": digest, + "policy_implementation_digest_framing": DIGEST_FRAMING, + "policy_source_commit": commit, + "policy_source_files": [ + {"path": path, "blob_sha1": sha, "size_bytes": size} + for path, sha, size in sorted(entries, key=lambda e: e[0].encode("utf-8")) + ], + "policy_source_root": POLICY_SOURCE_ROOT, + "policy_source_selector": POLICY_SOURCE_SELECTOR, + "policy_source_tree": tree, + } + + +# -------------------------------------------------------------------------- +# The controls +# -------------------------------------------------------------------------- + +HEX40 = "0123456789abcdef" +FILE_ENTRY_KEYS = {"path", "blob_sha1", "size_bytes"} + + +def _is_hex(value: object, width: int) -> bool: + return (isinstance(value, str) and len(value) == width + and all(char in HEX40 for char in value)) + + +def _is_count(value: object) -> bool: + """An exact non-negative count. `bool` is excluded on purpose: in Python a + bool IS an int, and Round 9 of this PR was lost to exactly that.""" + return isinstance(value, int) and not isinstance(value, bool) and value > 0 + + +def _numbers(node: object) -> list[object]: + """Every numeric leaf anywhere in the document, bools included.""" + if isinstance(node, dict): + return [n for value in node.values() for n in _numbers(value)] + if isinstance(node, list): + return [n for item in node for n in _numbers(item)] + if isinstance(node, (int, float, bool)): + return [node] + return [] + + +def load_artifact() -> dict[str, object] | None: + if not FREEZE_ARTIFACT.exists(): + fail("freeze-artifact-shape", + f"{FREEZE_ARTIFACT.relative_to(ROOT).as_posix()} does not exist; step 4 " + "is the artifact, so its absence is the whole failure") + return None + try: + loaded = json.loads(FREEZE_ARTIFACT.read_text(encoding="utf-8")) + except (OSError, ValueError) as exc: + fail("freeze-artifact-shape", f"the artifact could not be read as JSON: {exc}") + return None + if not isinstance(loaded, dict): + fail("freeze-artifact-shape", f"the artifact is a {type(loaded).__name__}, not an object") + return None + return loaded + + +def control_artifact_shape(art: dict[str, object]) -> None: + """The whole permitted schema, enumerated. + + This is the control that keeps step 4 from becoming step 5. It does not list + the constant names that are forbidden today — `q`, `M`, `R_runs`, the ladder, + `G`, a fitted `A_abs`/`R_rel`, any measurement output — because such a list is + only ever as complete as the day it was written. It states what the artifact + MAY contain, and everything else is a failure by construction. + """ + problems: list[str] = [] + + expected = { + "artifact": ARTIFACT_NAME, + "policy_implementation_digest_framing": DIGEST_FRAMING, + "policy_source_root": POLICY_SOURCE_ROOT, + "policy_source_selector": POLICY_SOURCE_SELECTOR, + } + digests = ("measurement_harness_digest", "policy_implementation_digest") + shas = ("policy_source_commit", "policy_source_tree") + permitted = set(expected) | set(digests) | set(shas) | {"policy_source_files"} + + unexpected = sorted(set(art) - permitted) + missing = sorted(permitted - set(art)) + if unexpected: + problems.append(f"keys the freeze schema does not permit: {unexpected}; step 4 " + "freezes identity, and a field outside this set is step 5 " + "arriving early") + if missing: + problems.append(f"keys the freeze schema requires: {missing}") + + for key, literal in expected.items(): + if key in art and art[key] != literal: + problems.append(f"{key} is not the frozen literal") + for key in digests: + if key in art and not _is_hex(art[key], 64): + problems.append(f"{key} is not 64 lowercase hex characters") + for key in shas: + if key in art and not _is_hex(art[key], 40): + problems.append(f"{key} is not 40 lowercase hex characters") + + files = art.get("policy_source_files") + sizes: list[object] = [] + if not isinstance(files, list) or not files: + problems.append("policy_source_files is not a non-empty list") + else: + for index, entry in enumerate(files): + where = f"policy_source_files[{index}]" + if not isinstance(entry, dict): + problems.append(f"{where} is not an object") + continue + if set(entry) != FILE_ENTRY_KEYS: + problems.append(f"{where} keys are {sorted(entry)}, not {sorted(FILE_ENTRY_KEYS)}") + continue + path = entry["path"] + if not isinstance(path, str) or not path.startswith(POLICY_SOURCE_ROOT): + problems.append(f"{where} path is not under {POLICY_SOURCE_ROOT}") + elif not path.endswith(".py") or ".." in path: + problems.append(f"{where} path is not a plain *.py path") + if not _is_hex(entry["blob_sha1"], 40): + problems.append(f"{where} blob_sha1 is not 40 lowercase hex characters") + if not _is_count(entry["size_bytes"]): + problems.append(f"{where} size_bytes is not a positive exact count") + else: + sizes.append(entry["size_bytes"]) + + stray = [n for n in _numbers(art) if n not in sizes or isinstance(n, (bool, float))] + if stray: + problems.append(f"numbers that are not a recorded file size: {stray}; the only " + "quantity this artifact is allowed to carry is a byte length, " + "which is how a design constant is kept from moving in beside it") + + if problems: + fail("freeze-artifact-shape", "; ".join(problems)) + else: + ok("freeze-artifact-shape", + f"{len(permitted)} permitted keys and no others, every digest well-formed, " + f"and the only numbers present are the {len(sizes)} recorded byte lengths") + + +def control_ancestry(art: dict[str, object]) -> None: + commit = str(art.get("policy_source_commit", "")) + require_objects(commit) + head = _git("rev-parse", "HEAD")[1].decode().strip() + if _git("merge-base", "--is-ancestor", commit, "HEAD")[0] != 0: + # A truncated history answers "no" for a link it simply cannot see, which + # is indistinguishable from a real negative. Both fail; only the remedy + # differs, so the message has to say which one this is rather than let a + # shallow checkout read as a provenance break. + truncated = ("; the history here is truncated, so this answer is not " + "trustworthy either way and the job needs fetch-depth: 0" + if is_shallow() else "") + fail("freeze-ancestry", + f"the frozen source commit {commit[:12]} does not read as an ancestor of " + f"HEAD {head[:12]}{truncated}") + return + if commit == head: + fail("freeze-ancestry", + "the freeze commit is the source commit; the artifact has to live in a " + "descendant, or it would be part of the tree it freezes") + return + tree = _git("rev-parse", f"{commit}^{{tree}}")[1].decode().strip() + if tree != str(art.get("policy_source_tree", "")): + fail("freeze-ancestry", + f"policy_source_tree is {str(art.get('policy_source_tree'))[:12]} but " + f"{commit[:12]} has tree {tree[:12]}") + return + ok("freeze-ancestry", + f"{commit[:12]} is a strict ancestor of HEAD {head[:12]} and really carries " + f"tree {tree[:12]}") + + +def control_source_set(art: dict[str, object]) -> None: + commit = str(art.get("policy_source_commit", "")) + require_objects(commit) + actual = sorted(source_set_at(commit, POLICY_SOURCE_ROOT), + key=lambda e: e[0].encode("utf-8")) + files = art.get("policy_source_files") + recorded = [(str(e["path"]), str(e["blob_sha1"]), int(str(e["size_bytes"]))) + for e in files] if isinstance(files, list) else [] + if recorded != actual: + fail("freeze-source-set", + f"the artifact records {recorded} but git at {commit[:12]} has {actual}") + return + ok("freeze-source-set", + f"{len(actual)} file(s) recorded, each path, blob sha1 and byte length equal to " + f"git's own at {commit[:12]}") + + +def control_source_root_clean(art: dict[str, object]) -> None: + """Nothing under the policy root may sit outside the `*.py` selector. + + The selector the owner specified covers `*.py`. That leaves a gap it does not + mention: a `constants.json` dropped beside the module would be under the frozen + root, invisible to the digest, and a perfectly comfortable home for `q`. The + digest still covers exactly `*.py`; this refuses the gap instead of widening it. + """ + commit = str(art.get("policy_source_commit", "")) + require_objects(commit) + problems: list[str] = [] + for where in (commit, "HEAD"): + rc, out = _git("ls-tree", "-r", "--long", "-z", where, "--", POLICY_SOURCE_ROOT) + if rc != 0: + problems.append(f"git could not list {POLICY_SOURCE_ROOT} at {where[:12]}") + continue + outside = sorted(p for p, _, _ in _parse_ls_tree(out) if not p.endswith(".py")) + if outside: + problems.append(f"at {where[:12]}, {outside} sit under the frozen root but " + "outside the *.py selector, so the digest does not cover them") + if problems: + fail("freeze-source-root-clean", "; ".join(problems)) + else: + ok("freeze-source-root-clean", + f"every committed path under {POLICY_SOURCE_ROOT} is a *.py the digest covers, " + "at the frozen commit and at HEAD") + + +def control_digest(art: dict[str, object]) -> None: + commit = str(art.get("policy_source_commit", "")) + require_objects(commit) + entries = source_set_at(commit, POLICY_SOURCE_ROOT) + recomputed = implementation_digest([(p, blob_at(sha)) for p, sha, _ in entries]) + frozen = str(art.get("policy_implementation_digest", "")) + if recomputed != frozen: + fail("freeze-digest", + f"the frozen digest is {frozen[:12]} but the blobs at {commit[:12]} hash " + f"to {recomputed[:12]}") + return + ok("freeze-digest", + f"{frozen[:12]}… recomputed from {len(entries)} git blob(s) at {commit[:12]}, " + "under the framing the artifact states") + + +def control_source_unchanged(art: dict[str, object]) -> None: + """The freeze commit must not have touched the tree it freezes. + + Blob sha1s are compared rather than working-tree bytes: a CRLF checkout makes + an identical file look different on disk, which is the Round 3 defect, and the + digest is over git blob bytes anyway. + """ + commit = str(art.get("policy_source_commit", "")) + require_objects(commit) + at_source = sorted(source_set_at(commit, POLICY_SOURCE_ROOT)) + at_head = sorted(source_set_at("HEAD", POLICY_SOURCE_ROOT)) + if at_source != at_head: + fail("freeze-source-unchanged", + f"the policy source at HEAD is {at_head}, but the freeze was taken over " + f"{at_source}; the freeze commit changed the tree it froze") + return + ok("freeze-source-unchanged", + f"all {len(at_head)} policy source blob(s) are byte-identical at HEAD and at " + f"{commit[:12]}") + + +def control_harness_untouched(art: dict[str, object]) -> None: + recorded = str(art.get("measurement_harness_digest", "")) + working = pb.harness_digest() + at_head = pb.harness_digest_at(ROOT, "HEAD") + problems: list[str] = [] + if working != recorded: + problems.append(f"the working tree harness digest is {working[:12]}, not {recorded[:12]}") + if at_head != recorded: + problems.append(f"the harness digest at HEAD is {str(at_head)[:12]}, not {recorded[:12]}") + if problems: + fail("freeze-harness-untouched", "; ".join(problems) + + "; the freeze commit moved the measurement instrument, which would " + "invalidate every recording taken against it") + else: + ok("freeze-harness-untouched", + f"{recorded[:12]}… unchanged, in the working tree and at HEAD") + + +def run() -> int: + art = load_artifact() + if art is not None: + control_artifact_shape(art) + for control in (control_ancestry, control_source_set, control_source_root_clean, + control_digest, control_source_unchanged, control_harness_untouched): + try: + control(art) + except FreezeRefused as exc: + fail(control.__name__.replace("control_", "freeze-").replace("_", "-"), + f"refused rather than reporting a pass it cannot support: {exc}") + print() + print(f"calibration freeze controls: {len(_PASSES)} passed, {len(_FAILURES)} failed") + return 1 if _FAILURES else 0 + + +def emit() -> int: + """Step 4, run once: compute the freeze from git and write the artifact.""" + head = _git("rev-parse", "HEAD")[1].decode().strip() + freeze = build_freeze(head) + FREEZE_ARTIFACT.parent.mkdir(parents=True, exist_ok=True) + FREEZE_ARTIFACT.write_text(json.dumps(freeze, indent=2, sort_keys=True) + "\n", + encoding="utf-8") + print(f"wrote {FREEZE_ARTIFACT.relative_to(ROOT).as_posix()}") + print(json.dumps(freeze, indent=2, sort_keys=True)) + return 0 + + +if __name__ == "__main__": + sys.exit(emit() if "--emit" in sys.argv[1:] else run()) diff --git a/tests/test_calibration_policy.py b/tests/test_calibration_policy.py new file mode 100644 index 00000000..9e82a5af --- /dev/null +++ b/tests/test_calibration_policy.py @@ -0,0 +1,758 @@ +#!/usr/bin/env python3 +"""#263-A calibration policy — controls for the pure implementation. + +The policy is step 2 of the ratified twelve-step sequence, written before any +training corpus exists. Every claim it makes can therefore be checked without a +clock, and is checked here by running it rather than by reading it: + + calib-no-defaults no parameter anywhere carries a numeric default + calib-representation rationals are reduced pairs, counts are integers + calib-design-set all five design constants are required, none default + calib-cell-verdict four ways, with the ratified inequalities exact + calib-symmetry swapping the two runs never changes a verdict + calib-aggregation strict precedence, never a tolerated-failure count + calib-fit exact vertex enumeration matches a grid, and is stable + calib-select-n the smallest rung within G, always defined + calib-purity no clock, no files, no randomness + calib-exact-domain a float cannot enter, and no output leaves Fraction + +`calib-no-defaults` is the one the owner's last P0 asked for directly: the old +wording named only the constants that appear in a formula, which left an +implementation free to hard-code `R_runs` or the ladder without contradicting it. + +Failures print `FAIL[]: `; nothing stops at the first one. + +Run: python tests/test_calibration_policy.py +""" + +from __future__ import annotations + +import ast +import inspect +import sys +from fractions import Fraction +from itertools import product +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts" / "calibration")) + +import policy as pol # noqa: E402 + +_FAILURES: list[tuple[str, str]] = [] +_PASSES: list[str] = [] + +POLICY_SOURCE = ROOT / "scripts" / "calibration" / "policy.py" + + +def fail(check: str, detail: str) -> None: + _FAILURES.append((check, detail)) + print(f"FAIL[{check}]: {detail}") + + +def ok(check: str, detail: str = "") -> None: + _PASSES.append(check) + print(f"ok[{check}]: {detail}" if detail else f"ok[{check}]") + + +def _constants(**overrides: object) -> pol.DesignConstants: + """Synthetic design constants for the controls. + + These are TEST FIXTURES, not proposed values. The policy itself holds none, + which is what `calib-no-defaults` exists to prove; a control still has to + hand it something to exercise the arithmetic. + """ + spec: dict[str, object] = {"q": (3, 4), "m": (2, 1), "r_runs": 3, + "n_ladder": (5, 15), "g": (1, 10)} + spec.update(overrides) + return pol.DesignConstants.from_committed(**spec) # type: ignore[arg-type] + + +# --- the one the owner asked for --------------------------------------------- + + +def control_no_defaults() -> None: + """No parameter anywhere carries a numeric default. + + A default is how a constant nobody ratified gets into the code while every + sentence about required arguments stays technically true. The rule checked + here is mechanical and total: a default must be absent or `None`. `None` + is allowed only because the verdict record's optional output fields use it. + """ + problems = [] + seen = 0 + for name, obj in vars(pol).items(): + if name.startswith("_"): + continue + targets = [] + # Only what this module DEFINES. `dataclass` and friends are imported + # into its namespace and their defaults are not the policy's business -- + # the first version of this control reported ten findings about + # `dataclass(frozen=False)`, which is a control measuring the wrong thing. + if inspect.isfunction(obj) and obj.__module__ == pol.__name__: + targets.append((name, obj)) + elif inspect.isclass(obj) and obj.__module__ == pol.__name__: + for attr, member in vars(obj).items(): + if inspect.isfunction(member): + targets.append((f"{name}.{attr}", member)) + elif isinstance(member, classmethod): + targets.append((f"{name}.{attr}", member.__func__)) + for label, fn in targets: + seen += 1 + for param in inspect.signature(fn).parameters.values(): + if param.default is inspect.Parameter.empty or param.default is None: + continue + problems.append(f"{label}({param.name}=) defaults to {param.default!r}; " + "a default is how an unratified constant gets in while " + "the sentence about required arguments stays true") + + # And the module must hold no bare number at module level either. A constant + # does not need to be a default to be a constant. + for name, obj in vars(pol).items(): + if name.startswith("_"): + continue + numeric = isinstance(obj, Fraction) or (isinstance(obj, int) + and not isinstance(obj, bool)) + if numeric: + problems.append(f"module-level {name} = {obj!r} is a bare number; the policy " + "carries no values") + + if seen < 8: + problems.append(f"only {seen} callables were inspected; the walk is not finding " + "the module's surface") + if problems: + fail("calib-no-defaults", "; ".join(problems)) + else: + ok("calib-no-defaults", f"{seen} callables inspected, no numeric default and no " + "module-level value anywhere") + + +def control_design_set() -> None: + """All five design constants are required, and each is validated.""" + problems = [] + fields = set(pol.DesignConstants.__dataclass_fields__) + want = {"q", "m", "r_runs", "n_ladder", "g"} + if fields != want: + problems.append(f"DesignConstants carries {sorted(fields)}, want {sorted(want)}; " + "R_runs and the ladder decide corpus cardinality and N selection " + "and cannot live outside the design set") + + for missing in sorted(want): + spec = {"q": (3, 4), "m": (2, 1), "r_runs": 3, "n_ladder": (5, 15), "g": (1, 10)} + del spec[missing] + try: + pol.DesignConstants.from_committed(**spec) # type: ignore[arg-type] + except TypeError: + pass + except Exception as exc: + problems.append(f"omitting {missing} raised {type(exc).__name__}, not TypeError") + else: + problems.append(f"DesignConstants was built without {missing}; it has a default") + + # Ranges, each refused by the field that owns it. + for label, overrides in ( + ("q at 1", {"q": (1, 1)}), ("q at 0", {"q": (0, 1)}), + ("M at 1", {"m": (1, 1)}), ("M below 1", {"m": (1, 2)}), + ("G below 0", {"g": (-1, 10)}), + ("R_runs below 2", {"r_runs": 1}), + ("an empty ladder", {"n_ladder": ()}), + ("an unordered ladder", {"n_ladder": (15, 5)}), + ("a ladder with a repeat", {"n_ladder": (5, 5)}), + ("a zero rung", {"n_ladder": (0, 5)}), + ): + try: + _constants(**overrides) + except pol.PolicyRefused: + pass + except Exception as exc: + problems.append(f"{label} raised {type(exc).__name__}, not PolicyRefused: {exc}") + else: + problems.append(f"{label} was accepted") + + c = _constants() + if c.mandatory_stop != c.n_ladder[-1]: + problems.append("the mandatory stop is not the ladder's last rung") + if c.as_committed()["q"] != (3, 4): + problems.append(f"as_committed does not round-trip q: {c.as_committed()['q']}") + + if problems: + fail("calib-design-set", "; ".join(problems)) + else: + ok("calib-design-set", "all five constants required; every range refused by its " + "own field; the ladder's last rung is the mandatory stop") + + +def control_representation() -> None: + """Rationals are reduced pairs. Counts are integers. Floats are refused.""" + problems = [] + + for label, args in ( + ("a float numerator", (0.95, 1)), ("a float denominator", (19, 20.0)), + ("a decimal string", ("0.95", 1)), ("a bool", (True, 1)), + ("a zero denominator", (1, 0)), ("a negative denominator", (19, -20)), + ("an unreduced pair", (10, 20)), + ): + try: + pol.canonical_rational(args[0], args[1], name="probe") + except pol.PolicyRefused: + pass + except Exception as exc: + problems.append(f"{label} raised {type(exc).__name__}: {exc}") + else: + problems.append(f"{label} was accepted as canonical") + + if pol.canonical_rational(19, 20, name="probe") != Fraction(19, 20): + problems.append("a reduced pair did not round-trip") + if pol.as_pair(Fraction(19, 20)) != (19, 20): + problems.append("as_pair did not produce the canonical pair") + + for label, value in (("a float count", 5.0), ("a bool count", True), + ("a string count", "5")): + try: + pol.canonical_count(value, name="probe", minimum=2) + except pol.PolicyRefused: + pass + except Exception as exc: + problems.append(f"{label} raised {type(exc).__name__}: {exc}") + else: + problems.append(f"{label} was accepted as a count") + + # A count is an integer, NOT the pair (n, 1): the ladder takes ints. + try: + _constants(n_ladder=((5, 1), (15, 1))) + except pol.PolicyRefused: + pass + except Exception as exc: + problems.append(f"a ladder of pairs raised {type(exc).__name__}: {exc}") + else: + problems.append("a ladder written as rational pairs was accepted; counts and " + "rationals are different kinds and the representation says so") + + # Exact median: an even count must not go through a float. + got = pol.exact_median([Fraction(1), Fraction(2)], name="probe") + if got != Fraction(3, 2) or not isinstance(got, Fraction): + problems.append(f"the median of 1 and 2 is {got!r}, not the exact 3/2") + + if problems: + fail("calib-representation", "; ".join(problems)) + else: + ok("calib-representation", "floats, decimal strings, bools, zero and negative " + "denominators and unreduced pairs are all refused; " + "counts are integers and medians stay exact") + + +# --- the verdict -------------------------------------------------------------- + + +def _cell(a: Fraction, b: Fraction, key: str = "cell") -> pol.CellObservation: + return pol.CellObservation(key=key, median_a=a, median_b=b, exit_a=0, exit_b=0, + valid_a=True, valid_b=True) + + +def control_cell_verdict() -> None: + """Four ways, with the ratified inequalities landing exactly where written.""" + problems = [] + c = _constants(m=(2, 1)) + env = pol.Envelope(n=5, a_abs=Fraction(10), r_rel=Fraction(0)) # inner 10, outer 20 + + # Boundaries: inner inclusive, outer strict. + for delta, want in ((Fraction(0), "reproducible"), (Fraction(10), "reproducible"), + (Fraction(11), "inconclusive"), (Fraction(20), "inconclusive"), + (Fraction(21), "not-reproducible")): + got = pol.classify_cell(_cell(Fraction(100), Fraction(100) + delta), env, c) + if got.verdict != want: + problems.append(f"delta {delta} against inner 10 / outer 20 read as " + f"{got.verdict}, want {want}") + + # The invalid branches, each by the condition that owns it. + for label, obs in ( + ("a missing median", pol.CellObservation("c", None, Fraction(1), 0, 0, True, True)), + ("an invalid outcome", pol.CellObservation("c", Fraction(1), Fraction(1), 0, 0, + False, True)), + ("disagreeing exit codes", pol.CellObservation("c", Fraction(1), Fraction(1), 0, 2, + True, True)), + ): + got = pol.classify_cell(obs, env, c) + if got.verdict != "invalid": + problems.append(f"{label} read as {got.verdict}, want invalid") + + # A zero bound admits exact agreement and nothing else. + zero = pol.Envelope(n=5, a_abs=Fraction(0), r_rel=Fraction(0)) + if pol.classify_cell(_cell(Fraction(5), Fraction(5)), zero, c).verdict != "reproducible": + problems.append("a zero bound refused two identical medians") + if pol.classify_cell(_cell(Fraction(5), Fraction(6)), zero, c).verdict != "not-reproducible": + problems.append("a zero bound did not refuse a non-zero change") + + # The bound is evaluated at the MIDPOINT, not at either run. + slope = pol.Envelope(n=5, a_abs=Fraction(0), r_rel=Fraction(1, 10)) + got = pol.classify_cell(_cell(Fraction(100), Fraction(120)), slope, c) + if got.reference_duration != Fraction(110): + problems.append(f"the reference duration is {got.reference_duration}, not the " + "midpoint 110") + + if problems: + fail("calib-cell-verdict", "; ".join(problems)) + else: + ok("calib-cell-verdict", "inner inclusive, outer strict, the three invalid " + "conditions each refused by name, a zero bound admits " + "only exact agreement, and the bound sits at the midpoint") + + +def control_symmetry() -> None: + """Swapping the two runs never changes a verdict. Exhaustively, on a grid. + + This is the defect the policy exists to remove: the incumbent rule divides by + whichever run was recorded first, so for every positive tolerance there is a + band where the verdict depends on run order and nothing else. + """ + problems = [] + c = _constants(m=(3, 2)) + grid = [Fraction(n) for n in range(1, 40)] + checked = 0 + for env in (pol.Envelope(5, Fraction(1), Fraction(0)), + pol.Envelope(5, Fraction(0), Fraction(1, 20)), + pol.Envelope(5, Fraction(2), Fraction(1, 10))): + for a, b in product(grid, repeat=2): + forward = pol.classify_cell(_cell(a, b), env, c).verdict + reverse = pol.classify_cell(_cell(b, a), env, c).verdict + checked += 1 + if forward != reverse: + problems.append(f"medians {a} then {b} read {forward}, reversed {reverse}, " + f"under A_abs={env.a_abs} R_rel={env.r_rel}") + break + if problems: + break + if problems: + fail("calib-symmetry", "; ".join(problems)) + else: + ok("calib-symmetry", f"{checked} ordered median pairs across three envelopes, " + "and no verdict depends on which run was recorded first") + + +def control_aggregation() -> None: + """Strict precedence over cells, and never a tolerated-failure count.""" + problems = [] + + def verdicts(*names: str) -> list[pol.CellVerdict]: + return [pol.CellVerdict(f"c{i}", n, "") for i, n in enumerate(names)] + + cases = [ + (("reproducible",) * 5, "reproducible"), + (("reproducible", "inconclusive", "reproducible"), "inconclusive"), + (("reproducible", "not-reproducible", "inconclusive"), "not-reproducible"), + (("invalid", "not-reproducible", "inconclusive"), "invalid"), + (("reproducible",) * 99 + ("not-reproducible",), "not-reproducible"), + ] + for names, want in cases: + got = pol.classify_pair(verdicts(*names), []) + if got["verdict"] != want: + problems.append(f"{len(names)} cells {sorted(set(names))} aggregated to " + f"{got['verdict']}, want {want}") + + # One bad cell in a hundred is still a bad pair. If that ever stops being + # true, a tolerated-failure count has appeared. + many = pol.classify_pair(verdicts(*(("reproducible",) * 99 + ("not-reproducible",))), []) + if many["verdict"] != "not-reproducible": + problems.append("1 failing cell among 100 did not fail the pair; a tolerated " + "failure count has appeared") + + if pol.classify_pair(verdicts("reproducible"), ["environment fingerprint mismatch"] + )["verdict"] != "invalid": + problems.append("a pair-level invalidating condition did not make the pair invalid") + if pol.classify_pair([], [])["verdict"] != "invalid": + problems.append("a pair covering no cells was not invalid") + + if problems: + fail("calib-aggregation", "; ".join(problems)) + else: + ok("calib-aggregation", "precedence invalid > not-reproducible > inconclusive > " + "reproducible; one failing cell in a hundred still fails " + "the pair; a pair-level condition overrides every cell") + + +# --- the fit ------------------------------------------------------------------ + + +def control_fit() -> None: + """Exact vertex enumeration finds the optimum, and finds the same one twice.""" + problems = [] + c = _constants(q=(1, 2), r_runs=3) + + def rows(pairs: list[tuple[int, int]]) -> list[pol.Observation]: + return [pol.Observation(Fraction(t), Fraction(y)) for t, y in pairs] + + # Against a dense grid. The grid can only ever tie or lose, so a grid point + # beating the enumeration would falsify the construction the policy rests on. + data = rows([(1, 3), (4, 5), (9, 12), (16, 14), (25, 30)]) + fitted = pol.fit_envelope(5, data, c) + best = pol.pinball_loss(data, c.q, fitted.a_abs, fitted.r_rel) + steps = 60 + for ia in range(steps + 1): + a = Fraction(ia * 30, steps) + for ir in range(steps + 1): + r = Fraction(ir * 3, steps) + if pol.pinball_loss(data, c.q, a, r) < best: + problems.append(f"a grid point A={a} R={r} beat the enumerated optimum " + f"A={fitted.a_abs} R={fitted.r_rel}") + break + if problems: + break + + # Same bytes, same constants. That is the whole point of the tie-break. + again = pol.fit_envelope(5, rows([(1, 3), (4, 5), (9, 12), (16, 14), (25, 30)]), c) + if (again.a_abs, again.r_rel) != (fitted.a_abs, fitted.r_rel): + problems.append(f"two fits of identical data gave {(fitted.a_abs, fitted.r_rel)} " + f"and {(again.a_abs, again.r_rel)}") + + # A falling corpus: every pair-line has negative slope and is filtered out, so + # the optimum can ONLY sit on the a = 0 or r = 0 boundary. Checking + # non-negativity alone was not enough -- dropping both boundary families + # collapses the fit to the corner (0, 0), which is non-negative and wrong. + # The grid decides it instead. + falling_rows = rows([(1, 30), (10, 20), (20, 5)]) + falling = pol.fit_envelope(5, falling_rows, c) + if falling.a_abs < 0 or falling.r_rel < 0: + problems.append(f"a falling corpus produced A={falling.a_abs} R={falling.r_rel}; " + "a bound may not be negative anywhere") + falling_loss = pol.pinball_loss(falling_rows, c.q, falling.a_abs, falling.r_rel) + for ia in range(steps + 1): + a = Fraction(ia * 40, steps) + for ir in range(steps + 1): + r = Fraction(ir * 3, steps) + if pol.pinball_loss(falling_rows, c.q, a, r) < falling_loss: + problems.append(f"on a falling corpus a grid point A={a} R={r} beat the " + f"enumerated A={falling.a_abs} R={falling.r_rel}; the " + "boundary candidates are not being enumerated") + break + else: + continue + break + + # The tie-break as a rule, both keys. The second key is only reachable when + # two minimisers share an intercept, which no natural corpus in this control + # produces, so it is exercised directly rather than left unverified. + if pol.canonical_minimiser({(Fraction(1), Fraction(5)), (Fraction(1), Fraction(2)), + (Fraction(3), Fraction(0))}) != (Fraction(1), Fraction(2)): + problems.append("the tie-break did not take the smallest R_rel among minimisers " + "sharing the smallest A_abs") + if pol.canonical_minimiser({(Fraction(9), Fraction(0)), (Fraction(2), Fraction(7))} + ) != (Fraction(2), Fraction(7)): + problems.append("the tie-break did not take the smallest A_abs") + try: + pol.canonical_minimiser(set()) + except pol.PolicyRefused: + pass + else: + problems.append("canonicalising an empty minimiser set returned a value") + + # The tie-break, on a corpus whose optimum is genuinely NOT unique. Both + # (28/5, 9/5) and (11, 0) attain the same loss here; the ratified rule takes + # the smallest A_abs. Without a stated tie-break two correct implementations + # return different constants, which is the entire reason the rule exists. + tied_rows = rows([(8, 20), (8, 10), (3, 11)]) + tied_fit = pol.fit_envelope(5, tied_rows, c) + rival = (Fraction(11), Fraction(0)) + if pol.pinball_loss(tied_rows, c.q, *rival) != pol.pinball_loss( + tied_rows, c.q, tied_fit.a_abs, tied_fit.r_rel): + problems.append("the tied corpus no longer has two minimisers, so the tie-break " + "is not being exercised at all") + elif (tied_fit.a_abs, tied_fit.r_rel) != (Fraction(28, 5), Fraction(9, 5)): + problems.append(f"the tie-break returned A={tied_fit.a_abs} R={tied_fit.r_rel}; " + "the ratified rule takes the smallest A_abs, which is 28/5") + + # Fail-closed, three ways. + for label, args in ( + ("no observations", []), + ("one distinct duration", rows([(5, 1), (5, 2), (5, 3)])), + ): + try: + pol.fit_envelope(5, args, c) + except pol.PolicyRefused: + pass + except Exception as exc: + problems.append(f"{label} raised {type(exc).__name__}: {exc}") + else: + problems.append(f"{label} was fitted instead of refused") + try: + pol.fit_envelope(5, [pol.Observation(Fraction(1), Fraction(-1)), + pol.Observation(Fraction(2), Fraction(1))], c) + except pol.PolicyRefused: + pass + else: + problems.append("a negative y was fitted; y is an absolute difference") + + # Observations come from CONSECUTIVE pairs, R_runs - 1 of them. + obs = pol.observations_from_medians([Fraction(10), Fraction(14), Fraction(12)], + c, name="probe") + if len(obs) != c.r_runs - 1: + problems.append(f"{len(obs)} observations from {c.r_runs} medians") + if (obs[0].t, obs[0].y) != (Fraction(12), Fraction(4)): + problems.append(f"the first observation is {(obs[0].t, obs[0].y)}, want midpoint 12 " + "and absolute change 4") + try: + pol.observations_from_medians([Fraction(1), Fraction(2)], c, name="probe") + except pol.PolicyRefused: + pass + else: + problems.append("a corpus with the wrong number of runs per cell was accepted") + + if problems: + fail("calib-fit", "; ".join(problems)) + else: + ok("calib-fit", "no grid point beats the enumerated optimum; identical data give " + "identical constants; the bound stays non-negative; and an empty, " + "rank-deficient, negative or mis-sized corpus is refused") + + +def control_select_n() -> None: + """The smallest rung within G of the ladder's best width, and always defined.""" + problems = [] + c = _constants(n_ladder=(5, 15, 45), g=(1, 10)) + durations = {n: [Fraction(100), Fraction(200)] for n in c.n_ladder} + + # 15 is best; 5 is within 10% of it; 5 must win because it is smaller. + envs = {5: pol.Envelope(5, Fraction(0), Fraction(105, 1000)), + 15: pol.Envelope(15, Fraction(0), Fraction(100, 1000)), + 45: pol.Envelope(45, Fraction(0), Fraction(99, 1000))} + got = pol.select_n(envs, durations, c) + if got["selected_n"] != 5: + problems.append(f"selected n={got['selected_n']}; n=5 is within (1 + G) of the " + "best width and is the smallest such rung") + + # Widen the gap and the small rung must lose. + envs[5] = pol.Envelope(5, Fraction(0), Fraction(500, 1000)) + got = pol.select_n(envs, durations, c) + if got["selected_n"] != 15: + problems.append(f"selected n={got['selected_n']} when n=5 is far outside the " + "margin; want 15") + + # G = 0 selects the argmin exactly, and a selection always exists. + strict = _constants(n_ladder=(5, 15, 45), g=(0, 1)) + if pol.select_n(envs, durations, strict)["selected_n"] != 45: + problems.append("G = 0 did not select the ladder's best rung") + + for label, kwargs in (("a missing envelope", {"envelopes": {5: envs[5]}}), + ("missing reference durations", {"durations": {5: durations[5]}})): + e = kwargs.get("envelopes", envs) + d = kwargs.get("durations", durations) + try: + pol.select_n(e, d, c) # type: ignore[arg-type] + except pol.PolicyRefused: + pass + except Exception as exc: + problems.append(f"{label} raised {type(exc).__name__}: {exc}") + else: + problems.append(f"{label} was selected over instead of refused") + + try: + pol.envelope_width(envs[5], []) + except pol.PolicyRefused: + pass + else: + problems.append("an empty workload universe produced a width") + + if problems: + fail("calib-select-n", "; ".join(problems)) + else: + ok("calib-select-n", "the smallest rung within (1 + G) of the best width wins; a " + "rung far outside the margin loses; G = 0 picks the argmin; " + "and a missing rung or empty universe is refused") + + +def control_exact_domain() -> None: + """A float cannot enter the policy, and nothing it computes leaves the exact domain. + + The boundary held at exactly one entry point once: `from_committed`. Every + other quantitative object -- `Envelope`, `Observation`, `CellObservation` -- + took whatever it was handed. That is not a typing nicety, because + `Fraction * float` is a **float** in Python: one float anywhere made the + fitted `R_rel`, the bound and the comparison that decides the verdict all + floating point. A module that refused a floating-point LP solver on + exactness grounds was then deciding its boundaries by rounding direction + through the front door of a dataclass. + + Both halves are checked here. A float must be refused rather than converted, + since `Fraction(0.1)` preserves the binary error with impeccable fidelity. + And the pipeline's outputs must all still be `Fraction`, or the refusals + above are guarding a door in a building with no walls. + """ + problems = [] + c = _constants() + good_env = pol.Envelope(n=5, a_abs=Fraction(1), r_rel=Fraction(1, 10)) + + refusals = [ + ("Envelope A_abs as float", + lambda: pol.Envelope(n=5, a_abs=0.1, r_rel=Fraction(0))), + ("Envelope R_rel as float", + lambda: pol.Envelope(n=5, a_abs=Fraction(0), r_rel=0.2)), + ("Envelope A_abs as int", + lambda: pol.Envelope(n=5, a_abs=1, r_rel=Fraction(0))), + ("Observation t as float", lambda: pol.Observation(t=3.14, y=Fraction(1))), + ("Observation y as float", lambda: pol.Observation(t=Fraction(1), y=0.2)), + ("CellObservation median as float", + lambda: pol.CellObservation("x", 1.1, Fraction(1), 0, 0, True, True)), + ("CellObservation exit code as float", + lambda: pol.CellObservation("x", Fraction(1), Fraction(1), 0.0, 0, True, True)), + ("CellObservation validity as a truthy non-boolean", + lambda: pol.CellObservation("x", Fraction(1), Fraction(1), 0, 0, 1, True)), + ("exact_median over floats", lambda: pol.exact_median([0.1, 0.2], name="probe")), + ("envelope_width over float durations", + lambda: pol.envelope_width(good_env, [0.5])), + # This one is caught twice: by the guard in `observations_from_medians` + # and, if that guard is removed, by `Observation` a line later. The + # refusal is therefore load-bearing but the guard itself is defence in + # depth, and no mutation of it can change the outcome. Recorded so the + # line does not read as untested coverage. + ("observations_from_medians over floats", + lambda: pol.observations_from_medians([0.1, 0.2, 0.3], c, name="probe")), + # The public ARITHMETIC surface, not just the constructors. Each of these + # was open after the first repair, and the first two can actually corrupt + # a computation: `inner` is where the envelope meets a caller's duration, + # and `pinball_loss` is the objective that decides the fit. + ("Envelope.inner with a float duration", lambda: good_env.inner(0.1)), + ("pinball_loss with a float q", + lambda: pol.pinball_loss([pol.Observation(Fraction(1), Fraction(1))], 0.75, + Fraction(0), Fraction(0))), + ("pinball_loss with a float A_abs", + lambda: pol.pinball_loss([pol.Observation(Fraction(1), Fraction(1))], c.q, + 0.1, Fraction(0))), + ("pinball_loss with a float R_rel", + lambda: pol.pinball_loss([pol.Observation(Fraction(1), Fraction(1))], c.q, + Fraction(0), 0.2)), + ("canonical_minimiser over float pairs", + lambda: pol.canonical_minimiser({(0.1, 0.2), (Fraction(9), Fraction(0))})), + # The serialiser cannot corrupt a fit, but a surface that fails closed + # everywhere except one function is a surface somebody will later argue + # about. It died with AttributeError before this. + ("as_pair of a float", lambda: pol.as_pair(0.5)), + ] + for label, thunk in refusals: + try: + thunk() + except pol.PolicyRefused: + pass + except Exception as exc: + problems.append(f"{label} raised {type(exc).__name__}, not PolicyRefused: {exc}") + else: + problems.append(f"{label} was accepted; a float that enters here makes every " + "downstream quantity floating point") + + # The positive half. Drive a full fit and verdict and check the TYPES that + # come out, not just that the refusals fire. + rows = [pol.Observation(Fraction(1), Fraction(3)), pol.Observation(Fraction(4), Fraction(5)), + pol.Observation(Fraction(9), Fraction(12))] + fitted = pol.fit_envelope(5, rows, c) + verdict = pol.classify_cell( + pol.CellObservation("x", Fraction(100), Fraction(110), 0, 0, True, True), fitted, c) + width = pol.envelope_width(fitted, [Fraction(100), Fraction(200)]) + minimised = pol.canonical_minimiser({(Fraction(1), Fraction(2)), (Fraction(3), Fraction(0))}) + produced = {"A_abs": fitted.a_abs, "R_rel": fitted.r_rel, "delta": verdict.delta, + "reference_duration": verdict.reference_duration, "inner": verdict.inner, + "outer": verdict.outer, "width": width, + "envelope.inner": fitted.inner(Fraction(100)), + "minimiser A_abs": minimised[0], "minimiser R_rel": minimised[1], + "loss": pol.pinball_loss(rows, c.q, fitted.a_abs, fitted.r_rel), + "median": pol.exact_median([Fraction(1), Fraction(2)], name="probe")} + for label, value in produced.items(): + if not isinstance(value, Fraction): + problems.append(f"{label} came out as {type(value).__name__} = {value!r}; the " + "computation left the exact domain") + pair = pol.as_pair(Fraction(19, 20)) + if pair != (19, 20) or not all(isinstance(x, int) for x in pair): + problems.append(f"as_pair produced {pair!r}, not the canonical integer pair") + + # The root cause of this finding was four forgotten `exact_rational()` calls, + # so the durable fix is not four more refusal cases -- it is a check that + # fails the next time a public entry point appears without one. Every public + # callable the module defines is enumerated and must be accounted for here. + covered = { + # guarded, and exercised by a refusal case above + "Envelope.inner", "as_pair", "canonical_minimiser", "canonical_rational", + "canonical_count", "exact_rational", "exact_median", "envelope_width", + "observations_from_medians", "pinball_loss", + "DesignConstants.from_committed", + # take already-validated policy objects, never a bare number + "classify_cell", "classify_pair", "fit_envelope", "select_n", + "DesignConstants.as_committed", "Envelope.as_committed", + } + public = set() + for name, obj in vars(pol).items(): + if name.startswith("_"): + continue + if inspect.isfunction(obj) and obj.__module__ == pol.__name__: + public.add(name) + elif inspect.isclass(obj) and obj.__module__ == pol.__name__: + for attr, member in vars(obj).items(): + fn = member.__func__ if isinstance(member, classmethod) else member + if inspect.isfunction(fn) and not attr.startswith("__"): + public.add(f"{name}.{attr}") + unaccounted = sorted(public - covered) + vanished = sorted(covered - public) + if unaccounted: + problems.append(f"public entry points with no exact-domain accounting: " + f"{unaccounted}; each is a place a float can enter, which is " + "exactly how the last four got in") + if vanished: + problems.append(f"this control still accounts for {vanished}, which the module no " + "longer defines; the list has drifted from the surface") + + if problems: + fail("calib-exact-domain", "; ".join(problems)) + else: + ok("calib-exact-domain", f"{len(refusals)} float and non-exact inputs refused at " + f"the door rather than converted, all {len(produced)} " + f"computed quantities come back Fraction, and all " + f"{len(public)} public entry points are accounted for") + + +def control_purity() -> None: + """No clock, no files, no randomness, no global state. Read from the source.""" + problems = [] + tree = ast.parse(POLICY_SOURCE.read_text(encoding="utf-8")) + allowed = {"collections.abc", "dataclasses", "fractions", "itertools", "math", + "__future__"} + imported = set() + for node in ast.walk(tree): + if isinstance(node, ast.Import): + imported.update(alias.name for alias in node.names) + elif isinstance(node, ast.ImportFrom) and node.module: + imported.add(node.module) + forbidden = imported - allowed + if forbidden: + problems.append(f"the policy imports {sorted(forbidden)}; a module that decides " + "admissibility must not reach a clock, a file or a generator") + + # No mutable module-level state that a second call could observe. + for node in tree.body: + if isinstance(node, ast.Assign): + for target in node.targets: + mutable = isinstance(node.value, (ast.List, ast.Dict, ast.Set)) + if isinstance(target, ast.Name) and mutable: + problems.append(f"module-level mutable {target.id}; the policy must " + "be pure and a shared container is not") + + if problems: + fail("calib-purity", "; ".join(problems)) + else: + ok("calib-purity", f"imports are {sorted(imported)} and nothing else; no mutable " + "module-level state") + + +def run() -> int: + control_no_defaults() + control_design_set() + control_representation() + control_cell_verdict() + control_symmetry() + control_aggregation() + control_fit() + control_select_n() + control_exact_domain() + control_purity() + print() + print(f"calibration policy controls: {len(_PASSES)} passed, {len(_FAILURES)} failed") + return 1 if _FAILURES else 0 + + +if __name__ == "__main__": + sys.exit(run()) diff --git a/tests/test_perf_instrument.py b/tests/test_perf_instrument.py new file mode 100644 index 00000000..9ca22d54 --- /dev/null +++ b/tests/test_perf_instrument.py @@ -0,0 +1,1523 @@ +#!/usr/bin/env python3 +"""#263-A — controls for the measurement instrument itself. + +The instrument's job is to produce numbers nobody can argue with later. These +controls check the properties that make that possible, and they check them by +exercising the mechanism rather than by reading its comments: + + perf-firewall-decisive a decisive workload cannot reach a clock pre-D7 + perf-firewall-calibration a calibration workload can (or the instrument is inert) + perf-reference-boundary the Python reference reads nothing its identity misses + perf-d7-phase-universe D7's metrics are not the attribution taxonomy + perf-gate-dormant the C1/C2 gate exists, is unarmed, and fails closed + perf-gate-arms-by-data arming needs committed data, never a source patch + perf-gate-payload-identity a damaged D7 freeze arms nothing, for its own reason + perf-session-drift a candidate that changes refuses the rest of the session + perf-notary-outside no digest is computed inside a measured interval + perf-child-accounting the kernel's per-child accounting, in ns, outside the clock + perf-provenance-complete every §9 field is present on a produced report + perf-no-engine-comparison the instrument emits no engine-comparison statistic + perf-smoke-untimed decisive smoke carries no timing slot at all + perf-phase-attribution no interval claims to be a phase it merely contains + perf-rung-outcome a cell is timed only if the invocation did the work + perf-digest-platform-stable the harness identity is content, not the checkout + +Failures print `FAIL[]: `; nothing stops at the first one. + +Run: python tests/test_perf_instrument.py +""" + +from __future__ import annotations + +import json +import os +import sys +import tempfile +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts")) + +import perf_baseline as pb # noqa: E402 + +_FAILURES: list[tuple[str, str]] = [] +_PASSES: list[str] = [] + + +def fail(check: str, detail: str) -> None: + _FAILURES.append((check, detail)) + print(f"FAIL[{check}]: {detail}") + + +def ok(check: str, detail: str = "") -> None: + _PASSES.append(check) + print(f"ok[{check}]: {detail}" if detail else f"ok[{check}]") + + +def _harness(tmp: Path, gate: pb.IdentityGate, candidate: Path | None = None) -> pb.Harness: + cand = candidate or (tmp / "fake-candidate") + if not cand.exists(): + cand.write_bytes(b"not a real binary, but it has an identity\n") + return pb.Harness(gate=gate, session=pb.SessionIdentity.freeze(cand), rss=pb.RssProbe(), + tmp=tmp, candidate=cand, warmup_discards=0, repetitions=1, seed=1) + + +# --- the firewall ---------------------------------------------------------- + + +def control_firewall() -> None: + """No decisive workload reaches a clock while the gate is unarmed. + + Both directions, because a firewall that refuses everything is not a + firewall, it is a broken instrument that happens to be safe. + """ + workloads, digest = pb.load_manifest() + gate = pb.IdentityGate.load(digest) + decisive_admitted, calibration_refused = [], [] + with tempfile.TemporaryDirectory(prefix="perf-fw-") as td: + h = _harness(Path(td), gate) + for w in workloads: + try: + h._assert_may_time(w) + except pb.FirewallBreach: + if not w.decisive: + calibration_refused.append(w.id) + else: + if w.decisive: + decisive_admitted.append(w.id) + if decisive_admitted: + fail("perf-firewall-decisive", + f"the timed path admitted decisive workloads with the gate unarmed: " + f"{decisive_admitted}") + else: + ok("perf-firewall-decisive", + f"all {sum(1 for w in workloads if w.decisive)} decisive workloads are refused a clock " + "while the D7 gate is dormant") + if calibration_refused: + fail("perf-firewall-calibration", + f"calibration workloads were refused too, so the firewall proves nothing about the " + f"decisive ones: {calibration_refused}") + else: + ok("perf-firewall-calibration", + f"all {sum(1 for w in workloads if not w.decisive)} calibration workloads are admitted " + "— the refusal above is selective, not blanket") + + +# --- the two identity domains ---------------------------------------------- + + +_AUDIT_PROBE = """ +import runpy, sys, os, json +opened, spawned = set(), [] +def hook(event, args): + if event == "open": + try: opened.add(os.fspath(args[0])) + except Exception: pass + elif event in ("subprocess.Popen", "os.exec", "os.posix_spawn"): + spawned.append(str(args[0]) if args else "?") +sys.addaudithook(hook) +out = sys.argv[3] +sys.argv = ["ownlang", "ownir", sys.argv[1], "--format", sys.argv[2]] +try: + runpy.run_module("ownlang", run_name="__main__", alter_sys=True) +except SystemExit: + pass +open(out, "w", encoding="utf-8").write(json.dumps({"opened": sorted(opened), "spawned": spawned})) +""" + + +def control_reference_boundary() -> None: + """The Python reference's behaviour is confined to the path its identity names. + + `python_reference_commit` / `python_reference_tree` content-address exactly + `PYTHON_REFERENCE_PATH`. If the measured path read a schema, a rule table or + a config from anywhere else in the repository, that identity would be too + narrow: the reference could change behaviour without changing its own sha, + which is the same defect class as an identity that names the checkout. + + Observed rather than argued: an audit hook records every file the reference + OPENS and every process it spawns, on both render surfaces. + """ + import subprocess + problems = [] + with tempfile.TemporaryDirectory(prefix="perf-refbound-") as td: + tmp = Path(td) + probe = tmp / "probe.py" + probe.write_text(_AUDIT_PROBE, encoding="utf-8") + workloads, _ = pb.load_manifest() + w = next(x for x in workloads if x.id == "cal-facts-tiny") + target = pb.materialize_calibration(w, tmp) + reference = str(ROOT / pb.PYTHON_REFERENCE_PATH) + + for fmt in ("human", "sarif"): + out = tmp / f"audit-{fmt}.json" + env = dict(os.environ) + env["PYTHONPATH"] = str(ROOT) + r = subprocess.run([sys.executable, str(probe), str(target), fmt, str(out)], + capture_output=True, env=env, cwd=str(ROOT), check=False) + if not out.is_file(): + problems.append(f"{fmt}: the audit probe produced nothing " + f"({r.stderr.decode('utf-8', 'replace')[:160]})") + continue + seen = json.loads(out.read_text(encoding="utf-8")) + escaped = [p for p in seen["opened"] + if p.startswith(str(ROOT) + os.sep) and not p.startswith(reference + os.sep)] + if escaped: + problems.append( + f"{fmt}: the reference opened {len(escaped)} repository file(s) outside " + f"{pb.PYTHON_REFERENCE_PATH}/, so its identity is too narrow: " + + ", ".join(sorted(p[len(str(ROOT)) + 1:] for p in escaped)[:4])) + if seen["spawned"]: + problems.append(f"{fmt}: the reference spawned {seen['spawned']}, whose identity " + "no reference sha covers") + if not any(p.startswith(reference + os.sep) for p in seen["opened"]): + problems.append(f"{fmt}: the probe observed no reference file at all, so it was " + "not exercising the reference and proves nothing") + if problems: + fail("perf-reference-boundary", "; ".join(problems)) + else: + ok("perf-reference-boundary", + f"on both render surfaces the reference opens only files under " + f"{pb.PYTHON_REFERENCE_PATH}/ and spawns nothing, so the content-addressed reference " + "identity covers what the reference actually does") + + +def control_d7_phase_universe() -> None: + """D7's metrics are not the instrument's attribution taxonomy. + + `PHASES` says what a timed interval CONTAINS. `D7_PHASES` says what the + owner preregisters a rule for. Building the universe from the former + demanded a rule for argv parsing on all 48 workload/platform/regime + combinations while omitting the end-to-end C# metric altogether — and the + fixture had been auto-marking every `frontend-extraction` cell + not-applicable, which is the code saying out loud that those cells were + never D7's. + """ + problems = [] + for name in ("cli-argv-parse", "cli-usage-refusal", "ownir-door-refusal", + "frontend-extraction"): + if name in pb.D7_PHASES: + problems.append(f"{name} is an attribution component, not a G3 metric, but it is " + "in D7_PHASES") + if name not in pb.D7_NON_METRIC_PHASES: + problems.append(f"{name} is not in D7_PHASES and carries no recorded reason for " + "being excluded; an exclusion has to be a decision, not an absence") + if "end-to-end-csharp" not in pb.D7_PHASES: + problems.append("the user-visible end-to-end C# run is not a D7 metric, though it is " + "one of the numbers the G3 verdict weighs most") + + # The universe must be built from the D7 vocabulary, not the other one. + axis = {c[0] for c in pb.expected_d7_cells()} + if axis != set(pb.D7_PHASES): + problems.append(f"expected_d7_cells() enumerates {sorted(axis)}, which is not D7_PHASES") + stray = axis & set(pb.D7_NON_METRIC_PHASES) + if stray: + problems.append(f"the D7 universe contains attribution-only phases: {sorted(stray)}") + + problems.extend(pb.d7_vocabulary_problems()) + + workloads, _ = pb.load_manifest() + ids = {pb.canonical_workload_id(w) for w in workloads if w.decisive} + want = len(pb.D7_PHASES) * len(ids) * len(pb.D7_PLATFORMS) * len(pb.D7_REGIMES) + if len(pb.expected_d7_cells()) != want: + problems.append(f"the universe is {len(pb.expected_d7_cells())} cells, not the " + f"{want} its own axes describe") + if problems: + fail("perf-d7-phase-universe", "; ".join(problems)) + else: + ok("perf-d7-phase-universe", + f"{len(pb.D7_PHASES)} G3 metrics x {len(ids)} canonical decisive workloads x " + f"{len(pb.D7_PLATFORMS)} platforms x {len(pb.D7_REGIMES)} regimes = " + f"{len(pb.expected_d7_cells())} cells; every attribution phase is either promoted " + "or excluded with a recorded reason, and no attribution-only phase is gated") + + +def control_gate_dormant() -> None: + """The gate is present and unarmed, and a malformed attestation fails CLOSED.""" + _, digest = pb.load_manifest() + gate = pb.IdentityGate.load(digest) + problems = [] + if gate.armed: + problems.append("the gate is ARMED — #263-A must never ship a D7 attestation") + if "harness_digest" not in gate.observed: + problems.append("the gate observes no harness identity, so C1 would have nothing to pin") + for key in ("workload_manifest_sha256", "python_reference_commit"): + if key not in gate.observed: + problems.append(f"the gate observes no {key}") + + saved = pb.D7_PAYLOAD + with tempfile.TemporaryDirectory(prefix="perf-gate-") as td: + try: + pb.D7_PAYLOAD = Path(td) / "payload.json" + pb.D7_PAYLOAD.write_text("{ this is not json", encoding="utf-8") + try: + pb.IdentityGate.load(digest) + except pb.InstrumentError: + pass + else: + problems.append("an unreadable D7 payload did not fail closed") + # The exact shape an older verifier armed on: computable values + # echoed back. It is refused here for not declaring itself a payload + # at all; the full §6 machinery is checked, against a real two-commit + # freeze, by perf-gate-payload-identity — one control per reason, so + # neither passes on the other's behalf. + pb.D7_PAYLOAD.write_text(json.dumps( + pb.IdentityGate.observe(digest)), encoding="utf-8") + try: + pb.IdentityGate.load(digest) + except pb.InstrumentError as e: + if "does not declare itself a D7 payload" not in str(e): + problems.append(f"a bare identity echo was refused by the wrong check: {e}") + else: + problems.append("a file echoing computable values back was accepted as a D7 " + "freeze") + finally: + pb.D7_PAYLOAD = saved + + if problems: + fail("perf-gate-dormant", "; ".join(problems)) + else: + ok("perf-gate-dormant", "the gate observes instrument, reference and workload identity, " + "is unarmed, and refuses both an unreadable file and a bare " + "identity echo") + + +# --- the D7 freeze, built for real in a throwaway repository ---------------- + + +def _git(repo: Path, *args: str) -> str: + """git in a throwaway repository, with background housekeeping OFF. + + `git commit` normally spawns `gc --auto`, which keeps writing inside `.git` + after the commit returns. When the fixture is then torn down, `rmtree` can + race that process and die with "Directory not empty: .../.git" — which is + exactly what CI hit on the added anchor fixtures, since they commit more + often than the old ones did. The repository lives for one check and is + deleted; it has nothing to gain from housekeeping and everything to lose + from a background writer. + """ + import subprocess + r = subprocess.run(["git", "-c", "user.email=c@example.invalid", "-c", "user.name=control", + "-c", "gc.auto=0", "-c", "maintenance.auto=false", + *args], cwd=str(repo), capture_output=True, check=False) + if r.returncode != 0: + raise RuntimeError(f"git {' '.join(args)} failed: {r.stderr.decode('utf-8', 'replace')}") + return r.stdout.decode("utf-8", "replace").strip() + + +def _canonical(obj: dict) -> str: + return json.dumps(obj, sort_keys=True, separators=(",", ":")) + + +def _protocol_cell(phase: str, workload: str, platform: str, regime: str, + na: bool = False) -> dict: + """One preregistered cell. + + Every value is a deliberately non-production placeholder. A fixture that + only passed with plausible NUMBERS would be proving that the gate reads + thresholds, which is the one thing it must never do. What is being checked + is that the preregistration is STRUCTURALLY there. + """ + dims = {"phase": phase, "workload_id": workload, "platform": platform, "regime": regime} + if na: + return {"dimensions": dims, + "not_applicable": ""} + return { + "dimensions": dims, + "bound": "", + "pass_fail_rule": "", + "inconclusive_band": "", + "repetition_ladder": dict.fromkeys(pb.D7_LADDER_KEYS, ""), + "comparison_statistic": "", + "rss_policy": "", + "allocation_policy": "", + } + + +def _valid_payload(observed: dict, anchor: str) -> dict: + """A payload that decides EVERY cell D7 covers. + + The previous fixture carried three synthetic cells and passed, which is the + defect it was supposed to be evidence against: a structural gate that never + asks whether all the cells are there accepts a preregistration covering half + a percent of the experiment. One slice is marked not-applicable on purpose, + so the accept direction exercises both shapes a cell is allowed to take. + """ + cells = {} + for phase, wid, platform, regime in pb.expected_d7_cells(): + # One slice marked not-applicable so the accept direction exercises both + # shapes a cell may take. WHICH slice is the fixture's arbitrary choice + # and asserts nothing about D7 — the previous fixture keyed this on + # `frontend-extraction`, which was the code quietly admitting those + # cells were never D7's while the universe demanded them anyway. + cells[f"{phase}|{wid}|{platform}|{regime}"] = _protocol_cell( + phase, wid, platform, regime, + na=(phase == "bridge-lowering" and platform == "windows")) + return { + "kind": pb.D7_PAYLOAD_KIND, + "schema": pb.D7_SCHEMA, + "cells": cells, + "rollups": dict.fromkeys(pb.D7_ROLLUP_LEVELS, ""), + pb.D7_PAYLOAD_ANCHOR: anchor, + **{k: observed[k] for k in pb.D7_PAYLOAD_BINDING_KEYS}, + "ratification": {"owner": "the owner", "ratified_at": "2026-01-01T00:00:00Z", + "signature": "none"}, + } + + +def _a_rule_cell(payload: dict) -> str: + """The id of a cell carrying a rule, chosen deterministically.""" + return next(k for k, v in sorted(payload["cells"].items()) + if pb.D7_CELL_NA_KEY not in v) + + +def _an_na_cell(payload: dict) -> str: + """The id of a cell marked not-applicable, chosen deterministically.""" + return next(k for k, v in sorted(payload["cells"].items()) + if pb.D7_CELL_NA_KEY in v) + + +def _seed_instrument(repo: Path) -> str: + """Commit S — the accepted #263-A instrument, in a checkout of its own. + + The old fixture committed a README and two JSON files and took ``observed`` + from the REAL repository. So the one thing the production lifecycle does + between acceptance and #263-B — move HEAD past S — could not happen here, + and the gate's ``instrument_tree_sha = git rev-parse HEAD`` check compared + the real repository's HEAD against a payload built from that same HEAD. The + fixture isolated production from precisely the effect it existed to check. + """ + repo.mkdir(parents=True, exist_ok=True) + _git(repo, "init", "-q") + for src in pb.INSTRUMENT_SOURCES: + dst = repo / pb._instrument_rel(src) + dst.parent.mkdir(parents=True, exist_ok=True) + dst.write_bytes(src.read_bytes()) + ref = repo / pb.PYTHON_REFERENCE_PATH / "reference.py" + ref.parent.mkdir(parents=True, exist_ok=True) + ref.write_text("# stands in for the Python reference source\n", encoding="utf-8") + _git(repo, "add", "-A") + _git(repo, "commit", "-q", "-m", "S: the accepted #263-A instrument") + return _git(repo, "rev-parse", "HEAD") + + +def _commit_file(repo: Path, rel: str, text: str, message: str) -> str: + path = repo / rel + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(text, encoding="utf-8") + _git(repo, "add", "-A") + _git(repo, "commit", "-q", "-m", message) + return _git(repo, "rev-parse", "HEAD") + + +def _build_freeze(repo: Path, manifest_digest: str, break_: str = "") -> dict: + """A real D7 lifecycle: S, ordinary work, C1, C2, then more ordinary work. + + Returns what the gate should observe in THIS repository. The commits after + C2 are the point: at #263-B the repository has moved on, and a gate that + demanded HEAD equal the accepted tree could never arm. + + Each ``break_`` damages exactly ONE property, so a refusal can be matched + against the check that owns it. A control where every broken input is + refused by the same over-broad check proves nothing about the other checks. + """ + anchor = _seed_instrument(repo) + nest = repo / "docs" / "evidence" + pay = nest / pb.D7_PAYLOAD.name + att = nest / pb.D7_ATTESTATION.name + pay_rel = f"docs/evidence/{pay.name}" + self_rel = pb._instrument_rel(pb.SELF) + + if break_ == "anchor-content-drift": + # A commit that HAS the instrument sources and IS an ancestor of C1, + # but whose instrument is not the one the freeze describes. + real = (repo / self_rel).read_bytes() + anchor = _commit_file(repo, self_rel, "# a different instrument\n", "drifted instrument") + (repo / self_rel).write_bytes(real) + _git(repo, "add", "-A") + _git(repo, "commit", "-q", "-m", "restore the instrument") + elif break_ in ("anchor-missing-sources", "anchor-not-ancestor"): + # A commit off to the side, so it is not an ancestor of C1. + head = _git(repo, "rev-parse", "HEAD") + _git(repo, "checkout", "-q", "--orphan", "sidelined") + _git(repo, "rm", "-rq", "--cached", ".") + for stray in ("docs", "scripts", pb.PYTHON_REFERENCE_PATH): + if (repo / stray).exists(): + import shutil + shutil.rmtree(repo / stray) + if break_ == "anchor-not-ancestor": + # Same instrument content, so only ancestry can catch it. + for src in pb.INSTRUMENT_SOURCES: + dst = repo / pb._instrument_rel(src) + dst.parent.mkdir(parents=True, exist_ok=True) + dst.write_bytes(src.read_bytes()) + (repo / "unrelated").write_text("not the instrument\n", encoding="utf-8") + _git(repo, "add", "-A") + _git(repo, "commit", "-q", "-m", "a commit that is not the accepted instrument") + anchor = _git(repo, "rev-parse", "HEAD") + _git(repo, "checkout", "-q", "-f", head) + _git(repo, "checkout", "-q", "-B", "main") + + # Ordinary work between acceptance and the freeze, so S is never the tip. + _commit_file(repo, "docs/notes/unrelated.md", "work after acceptance\n", "ordinary work") + + observed = pb.IdentityGate.observe(manifest_digest, repo) + payload = _valid_payload(observed, anchor) + + if break_ == "echo": + payload = {k: observed[k] for k in pb.D7_PAYLOAD_BINDING_KEYS} + elif break_ == "payload-incomplete": + payload.pop(pb.D7_PAYLOAD_PROTOCOL_KEYS[0]) + elif break_ == "no-ratification": + payload["ratification"] = {"owner": "the owner"} + elif break_ == "signed": + payload["ratification"]["signature"] = {"key_id": "DEADBEEF"} + elif break_ == "binding-mismatch": + payload["harness_digest"] = "f" * 64 + elif break_ == "anchor-not-hex": + payload[pb.D7_PAYLOAD_ANCHOR] = "the commit we all agreed on" + elif break_ == "anchor-not-a-commit": + payload[pb.D7_PAYLOAD_ANCHOR] = "0" * 40 + elif break_ == "proto-stub": + # The exact shape the previous fixture called valid. + for k in pb.D7_PAYLOAD_PROTOCOL_KEYS: + payload[k] = "" + elif break_.startswith("proto-"): + cells = payload["cells"] + rule = cells[_a_rule_cell(payload)] + na_id = _an_na_cell(payload) + if break_ == "proto-no-ladder": + rule.pop("repetition_ladder") + elif break_ == "proto-ladder-incomplete": + rule["repetition_ladder"].pop("escalation_stages") + elif break_ == "proto-no-statistic": + rule.pop("comparison_statistic") + elif break_ == "proto-no-inconclusive": + rule.pop("inconclusive_band") + elif break_ == "proto-no-dimension": + rule["dimensions"].pop("platform") + elif break_ == "proto-na-without-reason": + cells[na_id][pb.D7_CELL_NA_KEY] = "" + elif break_ == "proto-na-true": + # The exact escape hatch the PR body claimed was refused and was not. + cells[na_id][pb.D7_CELL_NA_KEY] = True + elif break_ == "proto-na-false": + cells[na_id][pb.D7_CELL_NA_KEY] = False + elif break_ == "proto-na-and-rule": + cells[na_id]["bound"] = "" + elif break_ == "proto-missing-cell": + cells.pop(_a_rule_cell(payload)) + elif break_ == "proto-attribution-phase": + # An attribution component dressed as a G3 metric. Refused because + # it is not in the universe, which is the whole point of the + # universe being D7's vocabulary rather than the instrument's. + cells["cli-argv-parse|repo-samples|linux|warm"] = _protocol_cell( + "cli-argv-parse", "repo-samples", "linux", "warm") + elif break_ == "proto-unknown-cell": + cells["invented|not-a-workload|linux|warm"] = _protocol_cell( + "invented", "not-a-workload", "linux", "warm") + elif break_ == "proto-duplicate-cell": + # The ShareX alias, added beside the id it aliases. The manifest + # declares the alias so the pair is never counted twice; a + # completeness check that missed this would hand ShareX two votes. + twin = next(k for k, v in sorted(cells.items()) + if v.get("dimensions", {}).get("workload_id") == "oss-ShareX.sln" + and pb.D7_CELL_NA_KEY not in v) + spec = json.loads(json.dumps(cells[twin])) + spec["dimensions"]["workload_id"] = "large-solution-control" + cells[twin.replace("oss-ShareX.sln", "large-solution-control")] = spec + elif break_ == "proto-rollup-workload-class": + payload["rollups"].pop("workload_class") + elif break_ == "proto-rollup-phase": + payload["rollups"].pop("phase") + elif break_ == "proto-rollup-overall": + payload["rollups"].pop("overall_g3") + + before_c1 = _git(repo, "rev-parse", "HEAD") + nest.mkdir(parents=True, exist_ok=True) + pay.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8") + _git(repo, "add", "-A") + _git(repo, "commit", "-q", "-m", "C1: freeze the payload") + c1 = _git(repo, "rev-parse", "HEAD") + blob = _git(repo, "rev-parse", f"{c1}:{pay_rel}") + + if break_ == "no-attestation": + return observed + + exact = pb.sha256_bytes(pay.read_bytes()) + attestation = { + "kind": pb.D7_ATTESTATION_KIND, + "schema": pb.D7_SCHEMA, + "payload_path": pay_rel, + "payload_commit_sha": c1, + "payload_blob_sha": blob, + "payload_sha256": exact, + "bindings": {k: payload.get(k) for k in pb.D7_PAYLOAD_BINDING_KEYS}, + "ratification_binding": payload.get("ratification"), + } + if break_ == "att-kind": + attestation["kind"] = "own.net/p022/something-else" + elif break_ == "att-incomplete": + attestation.pop("payload_blob_sha") + elif break_ == "wrong-exact-hash": + attestation["payload_sha256"] = "0" * 64 + elif break_ == "canonical-hash": + # The old scheme's hash: canonical JSON rather than the exact bytes §6 + # names. It "identifies" the payload only up to reformatting, which is + # the opposite of what an attestation is for. + attestation["payload_sha256"] = pb.sha256_bytes(_canonical(payload).encode()) + elif break_ == "wrong-path": + attestation["payload_path"] = "docs/evidence/some-other-file.json" + elif break_ == "bad-commit": + attestation["payload_commit_sha"] = "0" * 40 + elif break_ == "wrong-blob-sha": + attestation["payload_blob_sha"] = "0" * 40 + elif break_ == "rebound": + attestation["bindings"]["harness_digest"] = "e" * 64 + elif break_ == "rat-binding": + attestation["ratification_binding"] = {"owner": "somebody else", + "ratified_at": "2026-01-01T00:00:00Z", + "signature": "none"} + + att.write_text(json.dumps(attestation, indent=2) + "\n", encoding="utf-8") + + if break_ == "att-uncommitted": + return observed + if break_ == "not-descendant": + # A branch that forked BEFORE C1, carrying both files. The payload's + # bytes still match the blob at C1, and C1 still exists — only the + # attestation's commit fails to descend from it. + payload_text = pay.read_text(encoding="utf-8") + att_text = att.read_text(encoding="utf-8") + _git(repo, "checkout", "-q", "-f", "-b", "sidebranch", before_c1) + nest.mkdir(parents=True, exist_ok=True) + pay.write_text(payload_text, encoding="utf-8") + att.write_text(att_text, encoding="utf-8") + _git(repo, "add", "-A") + _git(repo, "commit", "-q", "-m", "C2 on a sibling branch") + return observed + + _git(repo, "add", "-A") + _git(repo, "commit", "-q", "-m", "C2: detached attestation") + + # #263-B does not run at C2. The repository keeps moving, and the gate has + # to survive that or the freeze is void the moment it is used. + _commit_file(repo, "docs/notes/after-the-freeze.md", "the work goes on\n", "post-freeze work") + + if break_ == "payload-modified-after-commit": + # Same canonical content, different bytes, and the attestation updated to + # match the NEW exact hash — so only git blob identity can catch it. + pay.write_text(json.dumps(payload, indent=4) + "\n", encoding="utf-8") + attestation["payload_sha256"] = pb.sha256_bytes(pay.read_bytes()) + att.write_text(json.dumps(attestation, indent=2) + "\n", encoding="utf-8") + return observed + + +def _with_freeze(repo: Path, fn): + saved_p, saved_a = pb.D7_PAYLOAD, pb.D7_ATTESTATION + try: + pb.D7_PAYLOAD = repo / "docs" / "evidence" / pb.D7_PAYLOAD.name + pb.D7_ATTESTATION = repo / "docs" / "evidence" / pb.D7_ATTESTATION.name + return fn() + finally: + pb.D7_PAYLOAD, pb.D7_ATTESTATION = saved_p, saved_a + + +# Each damaged freeze, and the phrase the check that owns it must produce. +# Matching the catcher is the point: without it, one broad refusal masquerades +# as twenty working checks. +_BROKEN_FREEZES = ( + # C1 shape and ratification + ("echo", "does not declare itself a D7 payload"), + ("payload-incomplete", "payload is incomplete, missing"), + ("no-ratification", "no complete ratification"), + ("signed", 'signature must be exactly "none"'), + ("binding-mismatch", "does not describe this instrument"), + # The instrument anchor: provenance, proved by content + ("anchor-not-hex", "is not a full commit sha"), + ("anchor-not-a-commit", "is not a commit in this repository"), + ("anchor-missing-sources", "does not contain the instrument sources"), + ("anchor-content-drift", "names a different instrument"), + ("anchor-not-ancestor", "is not an ancestor of the payload commit"), + # The frozen protocol: structure verified, values never read + ("proto-stub", "cells must be a non-empty object"), + ("proto-no-ladder", "missing: repetition_ladder"), + ("proto-ladder-incomplete", "repetition_ladder is missing: escalation_stages"), + ("proto-no-statistic", "missing: comparison_statistic"), + ("proto-no-inconclusive", "missing: inconclusive_band"), + ("proto-no-dimension", "is missing dimension(s): platform"), + ("proto-na-without-reason", "not_applicable with no stated reason"), + ("proto-na-true", "not_applicable with no stated reason"), + ("proto-na-false", "not_applicable with no stated reason"), + ("proto-na-and-rule", "applicable and inapplicable at once"), + ("proto-missing-cell", "does not decide every D7 cell"), + ("proto-unknown-cell", "not a cell D7 covers"), + ("proto-attribution-phase", "not a cell D7 covers"), + ("proto-duplicate-cell", "name the same D7 cell twice"), + ("proto-rollup-workload-class", "missing preregistered level(s): workload_class"), + ("proto-rollup-phase", "missing preregistered level(s): phase"), + ("proto-rollup-overall", "missing preregistered level(s): overall_g3"), + # C2 shape, hashes, git object identity and ancestry + ("no-attestation", "requires a DETACHED attestation"), + ("att-kind", "does not declare itself a D7 attestation"), + ("att-incomplete", "attestation is incomplete, missing"), + ("wrong-exact-hash", "exact bytes hash to"), + ("canonical-hash", "exact bytes hash to"), + ("wrong-path", "may not choose which file it is about"), + ("bad-commit", "is not a commit in this repository"), + ("wrong-blob-sha", "payload_blob_sha"), + ("payload-modified-after-commit", "modified after it was frozen"), + ("not-descendant", "not a descendant of the payload commit"), + ("att-uncommitted", "not committed in this repository"), + ("rebound", "re-binds values the payload froze differently"), + ("rat-binding", "ratifies something other than what was frozen"), +) + + + +def control_gate_payload_identity() -> None: + """The gate verifies the D7 freeze §6 defines, not a lookalike. + + §6 is two GIT COMMITS: an immutable payload commit, then a detached + attestation in a DESCENDANT commit naming that commit, that blob, and the + sha256 of the payload's exact bytes. An earlier implementation used the same + two letters for two sections inside one file — the word had changed + profession — and had no equivalent of payload_blob_sha, of exact-byte + hashing, or of the ancestry requirement at all. + """ + _, digest = pb.load_manifest() + problems = [] + for break_, expected in _BROKEN_FREEZES: + with tempfile.TemporaryDirectory(prefix=f"perf-d7-{break_}-", + ignore_cleanup_errors=True) as td: + repo = Path(td) / "repo" + try: + _build_freeze(repo, digest, break_) + except RuntimeError as e: + problems.append(f"{break_}: could not build the fixture ({e})") + continue + + def run(): + return pb.IdentityGate.load(digest) + try: + gate = _with_freeze(repo, run) + except pb.InstrumentError as e: + if expected not in str(e): + problems.append(f"{break_}: refused, but by the wrong check — expected " + f"{expected!r}, got {str(e)[:160]!r}") + else: + if gate.armed: + problems.append(f"{break_}: a damaged D7 freeze ARMED the gate; the check " + f"that should have said {expected!r} is not there") + else: + problems.append(f"{break_}: neither armed nor refused — the gate went " + "dormant on a payload that exists, which hides the damage") + if problems: + fail("perf-gate-payload-identity", "; ".join(problems)) + else: + ok("perf-gate-payload-identity", + f"{len(_BROKEN_FREEZES)} damaged D7 freezes, each refused by the check that owns it " + "(payload shape, ratification, bindings, anchor content and ancestry, protocol " + "completeness, missing/unknown/duplicated cells, boolean N/A, attestation shape, " + "exact-byte hash, blob sha, path, commit, ancestry, re-binding)") + + +def control_gate_arms_by_data() -> None: + """Arming is DATA, not a patch — and the harness digest does not move. + + This is the obligation that stops #263-B from being a different instrument: + if arming changed the digest D7 froze, the freeze would be void the moment + it was used. The freeze here is REAL — two commits in a throwaway repository + — because a fixture the production checks cannot see is not evidence that + the production checks pass. + """ + workloads, digest = pb.load_manifest() + before = pb.harness_digest() + problems = [] + with tempfile.TemporaryDirectory(prefix="perf-d7-arm-", + ignore_cleanup_errors=True) as td: + repo = Path(td) / "repo" + try: + _build_freeze(repo, digest) + except RuntimeError as e: + fail("perf-gate-arms-by-data", f"could not build a real freeze fixture: {e}") + return + + def run(): + gate = pb.IdentityGate.load(digest) + return gate, pb.harness_digest() + + try: + gate, after = _with_freeze(repo, run) + except pb.InstrumentError as e: + fail("perf-gate-arms-by-data", f"a VALID two-commit D7 freeze was refused: {e}") + return + + if not gate.armed: + problems.append("a valid freeze did not arm the gate, so #263-B could never run") + if after != before: + problems.append(f"arming moved the harness digest ({before[:12]} -> {after[:12]}): " + "the armed instrument is a different instrument") + leaked = [k for k, v in gate.pinned.items() if "never read" in str(v)] + if leaked: + problems.append(f"the gate recorded frozen PROTOCOL VALUES, not just field names: " + f"{leaked}") + if gate.pinned.get("protocol_fields_present") != ", ".join( + sorted(pb.D7_PAYLOAD_PROTOCOL_KEYS)): + problems.append("the gate did not record which protocol fields were present") + if gate.pinned.get("attestation_commit_sha") == gate.pinned.get("payload_commit_sha"): + problems.append("C1 and C2 were recorded as the same commit") + + # The lifecycle, asserted rather than assumed. S -> C1 -> C2 -> work, + # and #263-B runs at the tip. The previous gate compared the accepted + # tree against `git rev-parse HEAD`, which by this point equals none of + # them, so a correct freeze could never have armed. If these three ever + # collapse to one value the fixture has stopped reproducing production + # and this control is worthless again. + head = _git(repo, "rev-parse", "HEAD") + anchor = gate.pinned.get(pb.D7_PAYLOAD_ANCHOR) + c1 = gate.pinned.get("payload_commit_sha") + c2 = gate.pinned.get("attestation_commit_sha") + if len({head, anchor, c1, c2}) != 4: + problems.append(f"the fixture did not exercise a moving repository: anchor=" + f"{str(anchor)[:8]} c1={str(c1)[:8]} c2={str(c2)[:8]} " + f"head={head[:8]} — a gate can pass this without surviving #263-B") + if gate.pinned.get("instrument_at_anchor_digest") != before: + problems.append("the gate did not prove the instrument AT the anchor: it recorded " + f"{str(gate.pinned.get('instrument_at_anchor_digest'))[:12]} for a " + f"harness whose digest is {before[:12]}") + h = _harness(Path(td), gate) + dec = next(w for w in workloads if w.decisive) + try: + h._assert_may_time(dec) + except pb.FirewallBreach: + problems.append("the gate armed but the firewall still refused: the gate would have " + "no effect at #263-B") + if problems: + fail("perf-gate-arms-by-data", "; ".join(problems)) + else: + ok("perf-gate-arms-by-data", "two commits in order arm the gate with no source patch, " + "the harness digest is unchanged by arming, no frozen " + "protocol value is recorded, and the firewall then opens") + + +def control_phase_attribution() -> None: + """No interval claims to be a phase it merely contains. + + The floor rung is a usage error: the process starts, parses argv, writes a + refusal and exits. Calling that interval `direct` startup would let a later + subtraction hand D7 a phase nobody measured — the interval contains argv + handling and refusal rendering, and the production surface cannot separate + them without instrumentation #263-A is not authorized to add. + """ + # A refusal phase belongs to exactly the rung whose outcome PROVES that + # refusal happened. Without this the schema stayed internally consistent + # while saying something false: one bundled "argv parsing + usage refusal" + # phase sat on three rungs that never write a usage refusal, the report + # copied the same taxonomy faithfully, and a control that only compared the + # two agreed they matched. Two identical tables are not evidence; they are + # one claim written twice. + refusal_phase_evidence = { + "cli-usage-refusal": "usage-help", + "ownir-door-refusal": "door-refusal", + } + problems = [] + for r in pb.RUNGS: + for phase, required in refusal_phase_evidence.items(): + if phase in r.phases and r.evidence != required: + problems.append(f"{r.id}: claims {phase!r} but its outcome is proved by " + f"{r.evidence!r}, which demonstrates no such refusal happened") + if r.evidence == required and phase not in r.phases: + problems.append(f"{r.id}: its outcome proves {required!r}, so the interval " + f"contains {phase!r} and must name it") + # Stated separately as well as implied, because this is the exact shape + # the defect took: a refusal phase riding along on a successful rung. + if r.evidence.startswith("verdict") and any(p.endswith("-refusal") for p in r.phases): + problems.append(f"{r.id}: reaches a verdict, so no refusal phase belongs in it: " + f"{[p for p in r.phases if p.endswith('-refusal')]}") + undeclared = [p for p in r.phases if p not in pb.PHASES] + if undeclared: + problems.append(f"{r.id}: names phases absent from the vocabulary: {undeclared}") + if r.observability not in ("direct", "composed", "unavailable"): + problems.append(f"{r.id}: unknown observability {r.observability!r}") + if r.observability == "direct" and len(r.phases) != 1: + problems.append(f"{r.id}: claims a DIRECT measurement of {len(r.phases)} phases; a " + "composed interval is not a direct one") + if r.observability == "composed" and len(r.phases) < 2: + problems.append(f"{r.id}: labelled composed but names {len(r.phases)} phase(s)") + # The floor: a core invocation that takes no input still runs the CLI + # front door, so it must say so. + # Every real core invocation parses argv, floor or not. + if r.surface == "core" and "cli-argv-parse" not in r.phases: + problems.append(f"{r.id}: a core invocation always parses argv but does not name " + "that phase") + if r.surface == "core" and r.needs == "none": + if "cli-usage-refusal" not in r.phases: + problems.append(f"{r.id}: the smallest core invocation writes a usage refusal " + "but does not name that phase") + if r.observability == "direct": + problems.append(f"{r.id}: the ladder floor is a LOWER BOUND on startup, not " + "startup measured directly") + unused = sorted(set(pb.PHASES) - {p for r in pb.RUNGS for p in r.phases}) + if unused: + problems.append(f"phases declared but measured by no rung: {unused}") + + # The shipped evidence must agree with the shipped rung table. This is what + # makes "re-record after changing a rung" a gate rather than a promise. + # EVERY committed calibration artifact, found structurally rather than by a + # hardcoded path: records and exploratory sizing evidence alike must agree + # with the rung table they describe. Naming one file meant the check went + # blind the moment a run failed and the record was withheld — exactly when + # the remaining evidence most needs checking. + artifacts = [] + for cand in sorted((ROOT / "docs/evidence").glob("p022-263a-*.json")): + try: + doc = json.loads(cand.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError): + continue + if isinstance(doc, dict) and "rungs" in doc and "cells" in doc: + artifacts.append((cand, doc)) + if not artifacts: + problems.append("no calibration artifact is committed at all, so the rung table " + "describes nothing that was ever measured") + for report, rep in artifacts: + by_id = {r.id: r for r in pb.RUNGS} + shipped_rungs = [{"id": r.id, "surface": r.surface, "phases": list(r.phases), + "observability": r.observability, "expect_rc": list(r.expect_rc), + "evidence": r.evidence, "why": r.why} for r in pb.RUNGS] + if rep.get("rungs") != shipped_rungs: + problems.append(f"{report.name} records a different rung table than the instrument " + "now defines (ids, phases, expected exit codes or evidence have " + "moved): the report predates the instrument and must be re-recorded") + if rep.get("phases") != pb.PHASES: + problems.append(f"{report.name} records a different phase vocabulary than the " + "instrument now defines: the report predates the rung table and " + "must be re-recorded") + for cell in rep.get("cells", []): + rung = by_id.get(str(cell.get("rung"))) + if rung is None: + problems.append(f"{report.name}: cell names unknown rung {cell.get('rung')!r}") + continue + if list(cell.get("phases", [])) != list(rung.phases): + problems.append(f"{report.name}: a {rung.id} cell claims phases " + f"{cell.get('phases')} but the rung names {list(rung.phases)}") + break + if cell.get("observability") != rung.observability: + problems.append(f"{report.name}: a {rung.id} cell claims " + f"{cell.get('observability')!r} observability but the rung is " + f"{rung.observability!r}") + break + if problems: + fail("perf-phase-attribution", "; ".join(problems)) + else: + ok("perf-phase-attribution", "every rung's phases are declared, a refusal phase " + "appears only where the outcome proves that refusal, the " + "ladder floor is a bound rather than startup, and the " + "shipped report agrees with the rung table") + +def control_session_drift() -> None: + """A candidate that changes mid-session refuses the remainder.""" + problems = [] + with tempfile.TemporaryDirectory(prefix="perf-drift-") as td: + cand = Path(td) / "candidate.bin" + cand.write_bytes(b"binary A") + session = pb.SessionIdentity.freeze(cand) + try: + session.reverify() + except pb.InstrumentError as e: + problems.append(f"an unchanged candidate was refused: {e}") + cand.write_bytes(b"binary B, a different thing under test") + session.measurements_taken = 7 + try: + session.reverify() + except pb.InstrumentError as e: + if "7 measurement" not in str(e): + problems.append("the refusal does not say how many cells were already measured " + "on the old binary") + else: + problems.append("the candidate changed and the session carried on: half the cells " + "would be measured on a different binary") + if problems: + fail("perf-session-drift", "; ".join(problems)) + else: + ok("perf-session-drift", "candidate drift refuses the rest of the session and names how " + "many measurements preceded it") + + +def control_notary_outside_interval() -> None: + """No digest is computed inside a measured interval. + + Counted, not asserted: a gate that pays for itself out of the startup + benchmark is a defect wearing a safeguard's coat, and the only way to know + is to count the calls while the clock is running. + """ + problems = [] + calls = {"n": 0, "git": 0} + real = pb.sha256_file + real_git = pb._git_in + + def counting(path: Path) -> tuple[str, int]: + calls["n"] += 1 + return real(path) + + # The gate now shells out to git for blob identity, so obligation (c) has a + # second way to be violated: a verifier that pays for itself out of the + # startup benchmark is a defect whether it spends the time hashing or + # forking. + def counting_git(repo, *args): + calls["git"] += 1 + return real_git(repo, *args) + + with tempfile.TemporaryDirectory(prefix="perf-notary-") as td: + tmp = Path(td) + _, digest = pb.load_manifest() + h = _harness(tmp, pb.IdentityGate.load(digest)) + argv = [sys.executable, "-c", "pass"] + pb.sha256_file = counting # type: ignore[assignment] + pb._git_in = counting_git # type: ignore[assignment] + try: + h._run_once(argv, dict(os.environ), ROOT) + finally: + pb.sha256_file = real # type: ignore[assignment] + pb._git_in = real_git # type: ignore[assignment] + if calls["n"]: + problems.append(f"{calls['n']} digest(s) were computed inside the measured interval — " + "the notary is billing the benchmark for its own work") + if calls["git"]: + problems.append(f"{calls['git']} git invocation(s) ran inside the measured interval — " + "identity verification is billing the benchmark for its own work") + if problems: + fail("perf-notary-outside", "; ".join(problems)) + else: + ok("perf-notary-outside", "a measured interval computes no digests and forks no git; " + "identity is verified before the clock starts") + + +class _SlowRusage: + """A rusage whose every field costs 10 ms to read. + + The point is not to slow anything down. It is that the harness claims to + parse rusage AFTER the clock stops, and the only way to check a claim about + where code sits relative to an interval is to make that code expensive and + look at whether the interval grew. + """ + + _WATCHED = ("ru_maxrss", "ru_utime", "ru_stime", "ru_minflt", + "ru_majflt", "ru_nvcsw", "ru_nivcsw") + DELAY_S = 0.010 + + def __init__(self, real: object, log: list[str]) -> None: + self._real = real + self._log = log + + def __getattr__(self, name: str) -> object: + if name in self._WATCHED: + self._log.append(name) + time.sleep(self.DELAY_S) + return getattr(self._real, name) + + +def control_child_accounting() -> None: + """The kernel's per-child accounting: real, in nanoseconds, and off the clock. + + Round 7 asks which of a real process's costs a synthetic one does not have, + and the fields that separate the candidates -- CPU split, faults, context + switches -- were being read from wait4 and thrown away. Four things have to + hold at once, and each is exercised rather than asserted: + + * on POSIX every field arrives, as an integer, from THIS child; + * seconds are converted to nanoseconds, not passed through; + * off POSIX the fields are absent WITH A REASON, never zero; + * the parse happens after the interval closes, not inside it. + + The last is the one that would be invisible: a harness that read seven + rusage fields inside its own stopwatch would report the cost of its own + bookkeeping as the cost of the process it was measuring. + """ + problems = [] + posix = hasattr(os, "wait4") + + # (0) Two structural hazards, both of which would surface only mid-run. + # The accounting is spread into the sample row, so a field named like an + # existing key would silently overwrite the thing it collided with. + reserved = {"elapsed_ns", "rc", "peak_rss_bytes", "rss_unavailable_reason", + "accounting_unavailable_reason"} + collide = sorted(reserved & set(pb.ACCOUNTING_FIELDS)) + if collide: + problems.append(f"accounting fields {collide} collide with the sample row's own keys " + "and would overwrite them where the row is assembled") + # And a field with no declared unit raises KeyError inside measure_cell -- + # that is, in the middle of a measurement, which is the worst place to + # discover a typo in a constant. + unpriced = sorted(set(pb.ACCOUNTING_FIELDS) ^ set(pb.ACCOUNTING_UNITS)) + if unpriced: + problems.append(f"ACCOUNTING_FIELDS and ACCOUNTING_UNITS disagree about {unpriced}; a " + "field with no declared unit fails inside a measurement") + if problems: + # Terminal on purpose. Either fault makes measure_cell raise KeyError + # partway through a cell, and a control that runs on into that dies with + # a traceback naming the crash site rather than a FAIL line naming the + # cause. The first version of this check did exactly that. + fail("perf-child-accounting", "; ".join(problems)) + return + + # (1) The conversion itself, before any process is involved. A truncating + # conversion biases every sample the same direction, which is the kind of + # error that survives averaging. + for seconds, want, wrong in ( + (1.0, 1_000_000_000, "seconds are passed through unconverted"), + (0.5, 500_000_000, "the scale is wrong"), + (0.000_000_5, 500, "sub-microsecond time is truncated away"), + (0.012_345_678_9, 12_345_679, "rounding loses more than a nanosecond")): + got = pb.rusage_seconds_to_ns(seconds) + if got != want: + problems.append(f"rusage_seconds_to_ns({seconds}) = {got}, want {want}: {wrong}") + + with tempfile.TemporaryDirectory(prefix="perf-acct-") as td: + tmp = Path(td) + _, digest = pb.load_manifest() + h = _harness(tmp, pb.IdentityGate.load(digest)) + # A child that unmistakably burns CPU, so "did we convert to ns" has a + # visible answer. python -c pass would spend so little that a + # seconds-vs-nanoseconds mistake could hide behind rounding. + busy = [sys.executable, "-c", "sum(range(3_000_000))"] + + if posix: + row = h._run_once(busy, dict(os.environ), ROOT) + missing = [f for f in pb.ACCOUNTING_FIELDS if row.get(f) is None] + if missing: + problems.append(f"POSIX run produced no {missing}; wait4 hands these back and " + "the harness is dropping them again") + elif row.get("accounting_unavailable_reason"): + problems.append("POSIX run reported the accounting both present and unavailable") + else: + user = int(row["cpu_user_ns"]) # type: ignore[arg-type] + system = int(row["cpu_system_ns"]) # type: ignore[arg-type] + elapsed = int(row["elapsed_ns"]) # type: ignore[arg-type] + # Seconds left unconverted would round to 0 here; this child + # burns tens of milliseconds of user time. + if user < 1_000_000: + problems.append(f"cpu_user_ns = {user} for a child that burns tens of " + "milliseconds — the unit is seconds, not nanoseconds") + # And not scaled the other way: the child is single-threaded, so + # its CPU time cannot exceed its wall time. + if user + system > elapsed * 2: + problems.append(f"cpu_user_ns + cpu_system_ns = {user + system} exceeds " + f"2x elapsed_ns = {elapsed} for a single-threaded child") + if int(row["minor_faults"]) <= 0: # type: ignore[arg-type] + problems.append("minor_faults is 0 for a real process — the accounting is " + "not this child's") + for f in pb.ACCOUNTING_FIELDS: + if not isinstance(row[f], int) or isinstance(row[f], bool): + problems.append(f"{f} is {type(row[f]).__name__}, not an int") + + # (2) The parse is outside the interval. Made expensive on purpose: + # if the rusage were read before the clock stopped, elapsed_ns would + # swallow the delay and the difference below would vanish. + log: list[str] = [] + real_wait4 = os.wait4 + + def slow_wait4(pid: int, options: int) -> tuple[int, int, object]: + got_pid, status, ru = real_wait4(pid, options) + return got_pid, status, _SlowRusage(ru, log) + + os.wait4 = slow_wait4 # type: ignore[assignment] + try: + before = time.perf_counter_ns() + slow = h._run_once([sys.executable, "-c", "pass"], dict(os.environ), ROOT) + total = time.perf_counter_ns() - before + finally: + os.wait4 = real_wait4 # type: ignore[assignment] + + unread = [f for f in _SlowRusage._WATCHED if f not in log] + if unread: + problems.append(f"the harness never read {unread} from rusage, so the delay " + "check below proves nothing") + outside = total - int(slow["elapsed_ns"]) # type: ignore[arg-type] + budget = int(len(_SlowRusage._WATCHED) * _SlowRusage.DELAY_S * 1e9 * 0.7) + if outside < budget: + problems.append( + f"only {outside} ns of the call sat outside the measured interval, against " + f"{len(log)} deliberately slow rusage reads costing at least {budget} ns: " + "the accounting is being parsed inside the clock and billed to the child") + + # (3) The non-POSIX branch, driven on this machine. This is not a + # Windows test and does not claim to be one: it drives the real + # non-POSIX path of the real function, which is where a Windows run + # would land, and checks that absence is stated rather than zeroed. + probe = pb.RssProbe() + probe.mechanism = "none" + probe.reason = "forced non-POSIX path for the accounting control" + h2 = pb.Harness(gate=h.gate, session=h.session, rss=probe, tmp=tmp, + candidate=h.candidate, warmup_discards=0, repetitions=1, seed=1) + off = h2._run_once([sys.executable, "-c", "pass"], dict(os.environ), ROOT) + zeroed = [f for f in pb.ACCOUNTING_FIELDS if off.get(f) is not None] + if zeroed: + problems.append(f"without wait4 the harness still produced values for {zeroed}; " + "unmeasured accounting must be null, and a zero fault count would " + "read downstream as a flat measurement") + reason = str(off.get("accounting_unavailable_reason") or "") + if not reason: + problems.append("the accounting is absent with no reason given, which is exactly " + "how a silent absence becomes a measured zero") + elif "wait4" not in reason: + problems.append(f"the absence reason does not name the missing mechanism: {reason!r}") + + # (4) A cell must carry the fields out, or _run_once collects them for + # nobody. Whichever path the cell takes, the slots exist. + workloads, _ = pb.load_manifest() + floor = next(r for r in pb.RUNGS if r.needs == "none") + w = next(x for x in workloads if not x.decisive and pb._rung_accepts(floor, x)) + cell = h.measure_cell(floor, "python", w, None, "process-cold") + for key in ("accounting", "raw_accounting"): + if key not in cell: + problems.append(f"a cell carries no {key!r}: the accounting stops at _run_once") + acct = cell.get("accounting") + if cell.get("timing") is not None and posix: + if not isinstance(acct, dict): + problems.append("a timed cell summarized no accounting") + else: + empty = [f for f in pb.ACCOUNTING_FIELDS + if not isinstance(acct.get(f), dict) or acct[f].get("n") != h.repetitions] + if empty: + problems.append(f"a timed POSIX cell summarized {empty} over no samples") + for name, unit in (("cpu_user_ns", "ns"), ("minor_faults", "count")): + row_ = acct.get(name) + if isinstance(row_, dict) and f"median_{unit}" not in row_: + problems.append(f"{name} is not summarized in {unit}: " + f"{sorted(row_)}") + + if problems: + fail("perf-child-accounting", "; ".join(problems)) + else: + ok("perf-child-accounting", "wait4's CPU, fault and context-switch counters reach the " + "report in nanoseconds and integers, are parsed after the " + "clock stops, and are null with a stated reason where the " + "platform has no wait4") + + +# --- what the instrument emits --------------------------------------------- + + +def control_no_engine_comparison() -> None: + """The instrument records each engine's own numbers and nothing derived from both.""" + problems = list(pb.engine_comparison_problems({ + "cells": [{"engine": "python", "timing": {"median_ns": 1}}, + {"engine": "rust", "timing": {"median_ns": 2}}]})) + if problems: + problems = [f"a legitimate two-cell report was rejected: {problems}"] + # And the other direction: a report that DID carry a comparison must be caught. + if not pb.engine_comparison_problems({"summary": {"rust_vs_python_ratio": 0.5}}): + problems.append("a report carrying an engine-comparison key was accepted") + if not pb.engine_comparison_problems({"cells": [{"engine": "rust", "python_median_ns": 3}]}): + problems.append("a cell carrying another engine's number was accepted") + if problems: + fail("perf-no-engine-comparison", "; ".join(problems)) + else: + ok("perf-no-engine-comparison", "single-engine cells pass; a comparison key or a " + "cross-engine cell is refused") + + +def control_smoke_untimed() -> None: + """Decisive smoke carries no timing slot — not an empty one.""" + workloads, digest = pb.load_manifest() + problems = [] + with tempfile.TemporaryDirectory(prefix="perf-smoke-") as td: + h = _harness(Path(td), pb.IdentityGate.load(digest)) + for w in workloads: + if not w.decisive: + continue + row = h.smoke(w, ROOT / str(w.spec.get("path", ""))) + leaked = [k for k in row + if any(t in k for t in ("elapsed", "timing", "ns", "duration", "rss"))] + if leaked: + problems.append(f"{w.id}: smoke carries measurement keys {leaked}") + if row.get("tag") != pb.CALIBRATION_ONLY: + problems.append(f"{w.id}: smoke is untagged") + if problems: + fail("perf-smoke-untimed", "; ".join(problems)) + else: + ok("perf-smoke-untimed", "decisive smoke reports availability and shape only, tagged " + "CALIBRATION_ONLY, with no measurement slot to fill in later") + + +def control_provenance_complete() -> None: + """Every field §9 requires is present on a produced report.""" + required = [ + ("provenance", "tree_sha"), ("provenance", "python_reference_commit"), + ("provenance", "python_interpreter"), ("provenance", "workload_manifest_sha256"), + ("provenance", "environment"), ("provenance", "timestamp_utc"), + ("identity", "session_candidate"), ("harness", "seed"), + ("harness", "execution_order"), ("harness", "digest"), + ("noise", "before"), ("noise", "after"), + ] + committed = sorted(Path(ROOT / "docs/evidence").glob("p022-263a-calibration.*.json")) + if not committed: + ok("perf-provenance-complete", "no calibration report is committed yet; the shape is " + "checked when one is") + return + problems: list[str] = [] + # Pair integrity applies to EVERY committed artifact carrying a + # reproducibility verdict, not only to reports of record. Exploratory + # sizing evidence makes a claim about two runs too, and a claim whose + # other half was never committed cannot be recomputed by anyone. + for cand in sorted(Path(ROOT / "docs/evidence").glob("p022-263a-*.json")): + try: + doc = json.loads(cand.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError): + continue + repro_any = (doc or {}).get("reproducibility") + if not isinstance(repro_any, dict): + continue + e = repro_any.get("earlier_run") or {} + if not e.get("path") or not e.get("sha256"): + problems.append(f"{cand.name}: carries a reproducibility verdict but names no " + "earlier run, so the verdict rests on uncommitted data") + continue + mate = cand.parent / str(e["path"]) + if not mate.is_file(): + problems.append(f"{cand.name}: names earlier run {e['path']!r}, " + "not committed beside it") + elif pb.sha256_bytes(mate.read_bytes()) != e["sha256"]: + problems.append(f"{cand.name}: the committed {e['path']} does not hash to the value " + "its verdict was computed against") + + for path in committed: + rep = json.loads(path.read_text(encoding="utf-8")) + if rep.get("tag") != pb.CALIBRATION_ONLY: + problems.append(f"{path.name}: not tagged {pb.CALIBRATION_ONLY}") + for outer, inner in required: + if inner not in (rep.get(outer) or {}): + problems.append(f"{path.name}: missing {outer}.{inner}") + # Presence is not agreement. A report can carry a harness digest and a + # manifest digest that belong to some earlier tree and still tick every + # "field is present" box, which makes it a receipt rather than evidence. + if rep.get("harness", {}).get("digest") != pb.harness_digest(): + problems.append( + f"{path.name}: records harness digest " + f"{str(rep.get('harness', {}).get('digest'))[:12]} but the shipped instrument is " + f"{pb.harness_digest()[:12]} — it certifies a tree that is no longer here and " + "must be re-recorded") + if rep.get("provenance", {}).get("workload_manifest_sha256") != pb.load_manifest()[1]: + problems.append(f"{path.name}: records a workload manifest digest that is not the " + "shipped manifest's") + if not (rep.get("outcomes") or {}).get("valid"): + problems.append(f"{path.name}: was recorded with cells whose invocation did not do " + "the rung's work") + # CI legs may record "this environment is not measurement-grade" — that + # is a true statement about a hosted runner and not a defect. COMMITTED + # evidence may not: a report that ships as the calibration of record has + # to come from a machine that reproduced itself, on both counts. + repro = rep.get("reproducibility") + if repro is None: + problems.append(f"{path.name}: ships with no reproducibility check, so nothing says " + "a second run on that machine agreed with it") + elif not repro.get("reproduced"): + problems.append( + f"{path.name}: ships as the calibration of record but did not reproduce " + f"(outcomes {repro.get('outcomes_reproduced')}, timings " + f"{repro.get('timings_reproduced')}): " + f"{repro.get('cells_outside_tolerance')}{repro.get('cells_whose_outcome_changed')}") + # All three axes, checked on the shipped artifact rather than inferred. + adm = rep.get("admissibility") or {} + for axis in ("outcomes_reproduced", "timings_reproduced", "environment_valid"): + if not adm.get(axis): + problems.append(f"{path.name}: ships as the calibration of record with " + f"{axis}={adm.get(axis)!r}; a report of record needs all three") + if not adm.get("admissible"): + problems.append(f"{path.name}: is not marked admissible") + + # WARMUP is not a sizing knob. It moved from 2 to 3 alongside a + # repetitions escalation that had been authorised on its own, which + # turned one permitted knob into two turned after seeing which runs went + # red. Repetitions may differ from the default (that is the sanctioned + # escalation); warmup may not. + # A report of record names the tree it measured. With a dirty tree that + # sha names something other than what was on disk, so it names nothing. + # Both halves are held to it: run A written into the working tree before + # run B measures is exactly how a pair acquires dirty provenance. + if (rep.get("provenance") or {}).get("tree_dirty"): + problems.append(f"{path.name}: recorded on a DIRTY tree, so its tree_sha does not " + "identify what was measured") + warm = (rep.get("harness") or {}).get("warmup_discards") + if warm != pb.DEFAULT_WARMUP_DISCARDS: + problems.append(f"{path.name}: recorded with warmup_discards={warm}, but the policy " + f"default is {pb.DEFAULT_WARMUP_DISCARDS}. Warmup is not a sizing " + "knob; changing it is a deliberate policy edit, not a flag") + + # BOTH halves of the pair, or "reproduced" cannot be recomputed from + # committed evidence — only the program that already reached the verdict + # would know run A's numbers. + earlier = (repro or {}).get("earlier_run") or {} + if not earlier.get("path") or not earlier.get("sha256"): + problems.append(f"{path.name}: names no earlier run, so its reproducibility verdict " + "rests on data that was never committed") + else: + mate = path.parent / str(earlier["path"]) + if not mate.is_file(): + problems.append(f"{path.name}: names earlier run {earlier['path']!r}, which is " + "not committed beside it") + else: + got = pb.sha256_bytes(mate.read_bytes()) + if got != earlier["sha256"]: + problems.append(f"{path.name}: the committed {earlier['path']} hashes " + f"{got[:12]} but the verdict was computed against " + f"{str(earlier['sha256'])[:12]}") + # Every axis a pair must share, checked on the shipped files. + # The harness refuses a mismatched pair at measurement time; this + # is the second lock, on evidence that already exists. + mine = pb._pair_identity(rep) + for field in pb.PAIR_IDENTITY_FIELDS: + a, b = earlier.get(field), mine.get(field) + if a != b: + problems.append(f"{path.name}: run A and run B disagree on {field} " + f"({a!r} vs {b!r}); a pair measured under different " + "source, reference, candidate or settings is not a " + "reproducibility check") + for i, cell in enumerate(rep.get("cells", [])): + if not cell.get("raw_elapsed_ns"): + problems.append(f"{path.name}: cell {i} kept no raw per-iteration data") + break + problems.extend(f"{path.name}: {p}" for p in pb.engine_comparison_problems(rep)) + if rep.get("identity", {}).get("gate_armed"): + problems.append(f"{path.name}: recorded with the D7 gate ARMED") + if problems: + fail("perf-provenance-complete", "; ".join(problems)) + else: + ok("perf-provenance-complete", + f"{len(committed)} committed calibration report(s) carry every §9 field, name the " + "SHIPPED harness and manifest digests, retain raw per-iteration data, carry only " + "valid-outcome cells, and were taken with the gate dormant") + + +# --- rung outcomes ---------------------------------------------------------- + + +def control_rung_outcome() -> None: + """A cell is a measurement only if the invocation did the rung's work. + + The instrument once timed twelve command-not-found exits and reported them + as reproduced: with no .NET on PATH the launcher rungs died at 127 before + running anything, and nothing looked at the exit code. Both directions are + checked here, because a contract that refuses everything is not a contract, + it is a broken instrument that happens to be safe. + """ + problems = [] + _, digest = pb.load_manifest() + env = dict(os.environ) + env["PYTHONPATH"] = str(ROOT) + + # Structural: no rung may declare command-not-found a success, and every + # rung must name codes and an evidence kind the checker knows. + for r in pb.RUNGS: + if not r.expect_rc: + problems.append(f"{r.id}: declares no expected exit code, so any exit would pass") + if 127 in r.expect_rc: + problems.append(f"{r.id}: declares 127 (command-not-found) as doing its job") + try: + pb._evidence_problem(r.evidence, "ownir", "") + except pb.InstrumentError: + problems.append(f"{r.id}: names evidence kind {r.evidence!r} the checker cannot check") + try: + pb._evidence_problem("no-such-evidence", "", "") + except pb.InstrumentError: + pass + else: + problems.append("an unknown evidence kind was silently accepted") + + with tempfile.TemporaryDirectory(prefix="perf-outcome-") as td: + h = _harness(Path(td), pb.IdentityGate.load(digest)) + launcher = next(r for r in pb.RUNGS if r.surface == "launcher") + # Exactly the shape an absent toolchain produced. + bad = h.verify_outcome(launcher, [sys.executable, "-c", "raise SystemExit(127)"], + env, ROOT) + if bad["valid"]: + problems.append("a 127 exit was accepted as a launcher measurement — the defect that " + "let 12 command-not-found cells be reported as reproduced") + elif not any("127" in str(x) for x in bad["problems"]): + problems.append("the refusal does not name the command-not-found exit") + + # A process that exits on a DECLARED code but produced no verdict is + # still not a measurement: the exit code alone is not the contract. + silent = h.verify_outcome(launcher, [sys.executable, "-c", "pass"], env, ROOT) + if silent["valid"]: + problems.append("an invocation that exited 0 with no verdict was accepted; the " + "evidence check is doing nothing") + + # And the healthy direction, on the real production surface. + floor = next(r for r in pb.RUNGS if r.needs == "none") + good = h.verify_outcome(floor, [sys.executable, "-m", "ownlang", "ownir"], env, ROOT) + if not good["valid"]: + problems.append(f"the real floor invocation was refused: {good['problems']}") + + if problems: + fail("perf-rung-outcome", "; ".join(problems)) + else: + ok("perf-rung-outcome", "every rung declares exit codes and checkable evidence, 127 is " + "never success, a silent zero-exit is refused, and the real " + "production floor invocation is accepted") + + +def control_digest_platform_stable() -> None: + """The instrument's identity is its CONTENT, not the checkout it arrived in. + + D7's C1 freezes the harness digest and #263-B runs on both platforms, so a + digest that moves with line endings would arm a freeze on one platform and + refuse it on the other. It did: the same tree hashed af32f04ddbad on Linux + and 51ef2ca2422a on a Windows runner, where core.autocrlf rewrote the + instrument source on checkout. Nothing in the harness noticed until a + control compared the shipped report's digest against the running one. + """ + problems = [] + with tempfile.TemporaryDirectory(prefix="perf-eol-") as td: + lf = Path(td) / "lf.py" + crlf = Path(td) / "crlf.py" + body = "one\ntwo\nthree\n" + lf.write_bytes(body.encode()) + crlf.write_bytes(body.replace("\n", "\r\n").encode()) + + if pb.sha256_text_file(lf)[0] != pb.sha256_text_file(crlf)[0]: + problems.append("the text digest still moves with line endings, so the same " + "instrument has two identities and a frozen C1 fits only one " + "of them") + # And the raw hasher must stay raw: the candidate binary is bytes, and + # a hasher that normalized them would be a different kind of wrong. + if pb.sha256_file(lf)[0] == pb.sha256_file(crlf)[0]: + problems.append("sha256_file normalized its input; the candidate binary's " + "identity must be its actual bytes") + blob = Path(td) / "bin" + blob.write_bytes(b"\x00\r\n\x01") + if pb.sha256_file(blob)[0] != pb.sha256_bytes(b"\x00\r\n\x01"): + problems.append("sha256_file does not hash a binary verbatim") + if problems: + fail("perf-digest-platform-stable", "; ".join(problems)) + else: + ok("perf-digest-platform-stable", "the harness digest is content-addressed and " + "survives a CRLF checkout, while the candidate " + "binary is still hashed byte for byte") + + +def run() -> int: + control_firewall() + control_reference_boundary() + control_d7_phase_universe() + control_gate_dormant() + control_gate_arms_by_data() + control_gate_payload_identity() + control_session_drift() + control_notary_outside_interval() + control_child_accounting() + control_no_engine_comparison() + control_smoke_untimed() + control_provenance_complete() + control_phase_attribution() + control_rung_outcome() + control_digest_platform_stable() + print() + print(f"perf instrument controls: {len(_PASSES)} passed, {len(_FAILURES)} failed") + return 1 if _FAILURES else 0 + + +if __name__ == "__main__": + sys.exit(run()) diff --git a/tests/test_round7_apparatus.py b/tests/test_round7_apparatus.py new file mode 100644 index 00000000..bf504abc --- /dev/null +++ b/tests/test_round7_apparatus.py @@ -0,0 +1,1297 @@ +#!/usr/bin/env python3 +"""#263-A Round 7 — controls for the apparatus, before any measurement exists. + +The apparatus is a classifier and a structural preflight. Both can be exercised +exhaustively without a clock, and both are checked here by running them rather +than by reading them: + + round7-outcome-exclusivity the ratified rules never fire twice at once + round7-zero-guard A == 0 refuses; B == 0 alone does NOT + round7-boundaries every rule's exact edge lands where it was ratified + round7-regime-reading n-disagreement is P5; a cold/warm split is not + round7-preflight B1-B4 pass on healthy arms and each refuses its own damage + round7-schedule the execution order is blocked, seeded, and replayable + round7-execution-contract plan mode starts no clock; the timed bytes are the preflighted ones + round7-outcome-contract every spawn, warmups included, did the work its arm exists to do + round7-durable-refusal an invalid run leaves a black box, not just a traceback + round7-readout the reading is the preregistered D, and it is reproducible + +The exclusivity control matters most. The previous draft's outcome table let one +dataset satisfy two contradictory verdicts, and nothing in the process that +produced it would have noticed. It is checked here over an exact rational grid, +and checked in the other direction too: the old overlapping rule is handed to +the same census, which must report it broken. A control that only ever sees +correct input is a control nobody has tested. + +Failures print `FAIL[]: `; nothing stops at the first one. + +Run: python tests/test_round7_apparatus.py +""" + +from __future__ import annotations + +import json +import shutil +import subprocess +import sys +import tempfile +from fractions import Fraction +from itertools import product +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts" / "round7")) +sys.path.insert(0, str(ROOT / "scripts")) + +import classify as cl # noqa: E402 +import perf_baseline as pb # noqa: E402 +import preflight as pf # noqa: E402 +import readout as ro # noqa: E402 +import runner as rn # noqa: E402 +import schedule as sch # noqa: E402 +from elfread import Elf64 # noqa: E402 + +_FAILURES: list[tuple[str, str]] = [] +_PASSES: list[str] = [] + + +def fail(check: str, detail: str) -> None: + _FAILURES.append((check, detail)) + print(f"FAIL[{check}]: {detail}") + + +def ok(check: str, detail: str = "") -> None: + _PASSES.append(check) + print(f"ok[{check}]: {detail}" if detail else f"ok[{check}]") + + +# --- the classifier -------------------------------------------------------- + +# Sixths, so the ratified edges -- 3/2, 3, 2/3, 2 -- all land exactly on grid +# points instead of near them. Floats would decide those edges by rounding. +_GRID = tuple(Fraction(n, 6) for n in range(0, 37)) + + +def _census(rules_fired) -> dict[tuple[str, ...], list[tuple[Fraction, ...]]]: + """Every grid point where more than one rule fires, keyed by which rules.""" + out: dict[tuple[str, ...], list[tuple[Fraction, ...]]] = {} + for a, b, c in product(_GRID, repeat=3): + fired = rules_fired(a, b, c) + if len(fired) > 1: + out.setdefault(tuple(sorted(fired)), []).append((a, b, c)) + return out + + +def _old_rules_fired(a, b, c) -> tuple[str, ...]: + """The PREVIOUS draft's rules, kept only so the census can reject them. + + The single difference is P1's missing `C > 1.5A` clause. That one absence is + what let A=1, B=3, C=1.4 be both "the padded image explains it" and "the + phenomenon never reproduced". + """ + A, B, C = Fraction(a), Fraction(b), Fraction(c) + three_halves = Fraction(3, 2) + fired = [] + if C <= three_halves * A: + fired.append("P4") + if B >= 3 * A and C <= three_halves * B: # no C > 1.5A guard + fired.append("P1") + if B <= three_halves * A and C >= 3 * A: + fired.append("P2") + if B >= 3 * A and C >= 2 * B: + fired.append("P3") + return tuple(fired) + + +def control_outcome_exclusivity() -> None: + """The ratified rules overlap only where A and B are both exactly zero. + + Checked in both directions. The real rules must be clean everywhere else; + the old rules must be caught. Without the second half this control would + pass just as happily against a census that never looks at anything. + """ + problems = [] + overlaps = _census(cl.rules_fired) + + # (1) The claim the preregistration now makes, verbatim. + bad = {k: v for k, v in overlaps.items() if any(a != 0 or b != 0 for a, b, _ in v)} + if bad: + first = next(iter(bad.items())) + problems.append(f"the rules overlap away from A=B=0: {first[0]} at " + f"{[str(x) for x in first[1][0]]}") + if any("P1" in k for k in overlaps): + problems.append("P1 overlaps another rule; the ratified set says it is disjoint " + "unconditionally, because C > 1.5A cannot hold once the other " + "clauses force B and C to zero") + # (2) And the overlaps that DO exist must exist, or this proves nothing. + if not overlaps: + problems.append("no overlap was found anywhere, including at A=B=0 where P2 and " + "P3 provably coincide — the census is not evaluating the rules") + + # (3) The other direction: the old rules must be caught, away from zero. + old = _census(_old_rules_fired) + old_nonzero = {k: v for k, v in old.items() if any(a != 0 or b != 0 for a, b, _ in v)} + if not old_nonzero: + problems.append("the previous draft's overlapping P1 was NOT caught by this " + "census, so the census cannot detect the defect it exists for") + # And the owner's exact counterexample, at the exact numbers. + fired_old = _old_rules_fired(1, 3, Fraction(7, 5)) + if sorted(fired_old) != ["P1", "P4"]: + problems.append(f"A=1, B=3, C=1.4 fired {sorted(fired_old)} under the old rules; " + "the recorded defect was P1 and P4 together") + fired_new = cl.rules_fired(1, 3, Fraction(7, 5)) + if sorted(fired_new) != ["P4"]: + problems.append(f"A=1, B=3, C=1.4 fires {sorted(fired_new)} under the RATIFIED " + "rules; it must be P4 alone") + + # (4) The fail-closed backstop: ambiguity raises rather than picking. + try: + cl.outcome_at(0, 0, 5) + except cl.AmbiguousOutcome: + pass + except Exception as exc: + problems.append(f"an ambiguous triple raised {type(exc).__name__}, not " + f"AmbiguousOutcome: {exc}") + else: + problems.append("A=0, B=0, C=5 satisfies both P2 and P3 and the classifier " + "returned a single answer anyway — it chose") + + if problems: + fail("round7-outcome-exclusivity", "; ".join(problems)) + else: + ok("round7-outcome-exclusivity", + f"over {len(_GRID) ** 3} exact rational triples the ratified rules overlap " + f"only at A=B=0 ({sum(len(v) for v in overlaps.values())} such points, " + f"{sorted(overlaps)}), P1 overlaps nothing, and the previous draft's P1 is " + "still detected as broken") + + +def control_zero_guard() -> None: + """A == 0 refuses the regime. B == 0 alone is a result, not a refusal.""" + problems = [] + + def regime(a5, b5, c5, a15=None, b15=None, c15=None): + """Classify, turning a raise into a reportable finding. + + Without this the control dies on a traceback the moment the guard is + removed -- A=B=C=0 fires P2, P3 and P4 at once, so the classifier raises + AmbiguousOutcome and the run ends with a stack trace naming the raise + site and no FAIL line naming the cause. That exact shape was recorded as + a finding one round ago; it is not allowed to reappear here. + """ + second = (a5 if a15 is None else a15, b5 if b15 is None else b15, + c5 if c15 is None else c15) + try: + return cl.regime_outcome("process-cold", {5: (a5, b5, c5), 15: second}) + except cl.ClassifierError as exc: + problems.append(f"A={a5}, B={b5}, C={c5} raised {type(exc).__name__} instead " + f"of being routed to P5 by the zero-A guard: {exc}") + return cl.RegimeOutcome("process-cold", "", str(exc), {}) + + # A zero at EITHER count refuses the whole regime. + if regime(0, 0, 0).outcome != "P5": + problems.append("A=0 at both counts did not refuse") + if regime(0, 1, 4, a15=1, b15=1, c15=4).outcome != "P5": + problems.append("A=0 at n=5 alone did not refuse the regime") + if regime(1, 1, 4, a15=0, b15=1, c15=4).outcome != "P5": + problems.append("A=0 at n=15 alone did not refuse the regime") + + # B == 0 with a live A is a clean P2 and must survive. Routing it to P5 + # would discard one of the cleanest results the round can produce. + r = regime(1, 0, 4) + if r.outcome != "P2": + problems.append(f"A=1, B=0, C=4 classified {r.outcome}, not P2: the padded arm " + "shows no excess and the real binary does, which is exactly " + "what P2 means") + + # No epsilon. A tiny but non-zero A must classify, not refuse: a tolerance + # here would be an absolute threshold with no preregistered basis. + tiny = regime(Fraction(1, 10 ** 9), 0, 4) + if tiny.outcome == "P5" and "exactly 0" in tiny.why: + problems.append("a tiny but NON-ZERO A was refused by the zero guard; the guard " + "is exact zero, and an epsilon would be a new threshold") + + # And the guard must say why, not merely refuse. + if "multiplicative reference" not in regime(0, 0, 0).why: + problems.append("the zero-A refusal does not state its reason") + + if problems: + fail("round7-zero-guard", "; ".join(problems)) + else: + ok("round7-zero-guard", "A=0 at either repetition count refuses the regime with " + "a stated reason; B=0 with a live A still classifies " + "(A=1,B=0,C=4 -> P2); a non-zero A is never refused") + + +def control_boundaries() -> None: + """Each rule's exact edge lands where it was ratified, not one step away.""" + problems = [] + F = Fraction + cases = [ + # (A, B, C, expected, what the edge is) + (2, 0, 3, "P4", "C = 1.5A exactly is P4: the inequality is <=, and P1 needs >"), + (2, 6, 5, "P1", "C above 1.5A, B = 3A, and C inside [2/3B, 1.5B] = [4, 9]"), + (1, 3, 2, "P1", "C = (2/3)B exactly is inside P1's band"), + (1, 3, F(9, 2), "P1", "C = 1.5B exactly is inside P1's band"), + (1, 3, 6, "P3", "C = 2B exactly is P3, and 6 > 1.5*3 puts it outside P1's band"), + (2, 3, 6, "P2", "B = 1.5A exactly and C = 3A exactly is P2"), + (2, 3, F(59, 10), "P5", "B = 1.5A exactly but C just under 3A fires nothing"), + (1, 3, 5, "P5", "B = 3A but C sits above 1.5B and below 2B: no rule covers it"), + ] + for a, b, c, want, why in cases: + try: + got = cl.outcome_at(a, b, c) + except cl.ClassifierError as exc: + problems.append(f"A={a}, B={b}, C={c} raised {exc}") + continue + if got != want: + problems.append(f"A={a}, B={b}, C={c} -> {got}, want {want} ({why})") + + # Inputs that are not measurements are refused rather than classified. A + # non-finite drift falling through to P5 would read as a considered verdict. + for bad, label in ((float("nan"), "NaN"), (float("inf"), "infinity"), + (-1, "a negative drift"), (True, "a boolean")): + try: + cl.outcome_at(1, 1, bad) + except cl.ClassifierError: + pass + else: + problems.append(f"{label} was classified rather than refused") + + if problems: + fail("round7-boundaries", "; ".join(problems)) + else: + ok("round7-boundaries", f"{len(cases)} ratified edges land where the rules put " + "them, and a non-finite, negative or boolean drift is " + "refused rather than classified") + + +def control_regime_reading() -> None: + """Disagreement between counts is P5; disagreement between regimes is not.""" + problems = [] + cold = {5: (1, 0, 4), 15: (1, 0, 4)} # P2 at both counts + warm = {5: (1, 0, 1), 15: (1, 0, 1)} # P4 at both counts + + r = cl.regime_outcome("process-cold", {5: (1, 0, 4), 15: (1, 0, 1)}) + if r.outcome != "P5": + problems.append(f"n=5 P2 and n=15 P4 classified {r.outcome}, not P5") + elif "n=5" not in r.why or "n=15" not in r.why: + problems.append("the count-disagreement refusal does not name both counts") + + read = cl.read_round({"process-cold": cold, "warm": warm}) + per = read["per_regime"] + if per["process-cold"]["outcome"] != "P2" or per["warm"]["outcome"] != "P4": + problems.append(f"the regimes were not classified independently: {per}") + if not read["regime_split"]: + problems.append("a cold P2 against a warm P4 was not reported as a split") + if "NOT" not in str(read["regime_split_reading"]): + problems.append("the split reading does not say it is not P5 — the owner ruled a " + "split is a cache-sensitivity signal, and collapsing it into " + "inconclusive discards the round's most informative result") + same = cl.read_round({"process-cold": cold, "warm": cold}) + if same["regime_split"]: + problems.append("two identical regimes were reported as a split") + + # Only the ratified counts. n=25 is not a knob this round may reach for. + for bad in ({5: (1, 1, 1)}, {5: (1, 1, 1), 25: (1, 1, 1)}, + {5: (1, 1, 1), 15: (1, 1, 1), 25: (1, 1, 1)}): + try: + cl.regime_outcome("process-cold", bad) + except cl.ClassifierError: + pass + else: + problems.append(f"repetition counts {sorted(bad)} were accepted") + + if problems: + fail("round7-regime-reading", "; ".join(problems)) + else: + ok("round7-regime-reading", "n=5 against n=15 within a regime is P5; cold " + "against warm is reported as a split and not " + "collapsed; only n in {5,15} is accepted") + + +# --- the structural preflight ---------------------------------------------- + + +_DAMAGE = { + "padding dropped by the linker": ("""#include +const uint64_t own_round7_padding[200000] = { 1 }; +""", ("-fdata-sections",), ("-Wl,--gc-sections",), "B1"), + "padding present but never mapped": ("""__asm__(".section .own_round7_note,\\"\\",@progbits\\n" + ".globl own_round7_padding\\n" + ".type own_round7_padding,@object\\n" + "own_round7_padding:\\n" + ".fill 1600000, 1, 0\\n" + ".size own_round7_padding, 1600000\\n" + ".previous\\n"); +""", (), (), "B2"), + "padding sized nothing like arm C": ("""#include +const volatile uint64_t own_round7_padding[64] = { 1 }; +""", (), (), "B3"), +} + +_ALTERED_WORK = """#include +#include +int main(int argc, char **argv) { + if (argc < 2) return 2; + uint64_t n = strtoull(argv[1], NULL, 10); + volatile uint64_t x = 1; + for (uint64_t i = 0; i < n; i++) { + x = x * 1103515247ull + 12345ull; /* one constant changed */ + } + return (x == 0xFFFFFFFFFFFFFFFFull) ? 1 : 0; +} +""" + + +def control_preflight() -> None: + """B1-B4 pass on healthy arms, and each refuses the damage it owns. + + The damage is BUILT, not simulated: a real linker really does drop an + unreferenced non-volatile constant under --gc-sections, and a section + emitted with empty flags really is absent from every PT_LOAD. A fixture + that merely edited a dictionary would prove the checks can read a + dictionary. + """ + if sys.platform != "linux" or shutil.which("gcc") is None: + ok("round7-preflight", f"skipped on {sys.platform}: the arms are ELF binaries " + "built with gcc, and Round 7 is a Linux round. Nothing " + "is claimed about this platform") + return + candidate = ROOT / "rust/target/release/own-cli" + problems = [] + with tempfile.TemporaryDirectory(prefix="round7-pre-") as td: + tmp = Path(td) + + # (1) The healthy arms. + if candidate.is_file(): + record = pf.preflight(candidate, tmp / "healthy") + for name, res in record["checks"].items(): + if not res["pass"]: + problems.append(f"{name} failed on healthy arms: {res['why']}") + if record["checks"]["B4"]["test"] not in ("raw-bytes", + "address-stripped-disassembly"): + problems.append("B4 did not name which test decided") + else: + ok("round7-preflight", "arm C (rust/target/release/own-cli) is not built " + "here, so the healthy pass and B3 were not exercised") + return + + # (2) Each damage, refused by the check that owns it. + work_obj = tmp / "spin.o" + _gcc(["-O2", "-c", "-o", str(work_obj), str(pf.WORK_SOURCE)], problems) + arm_a = tmp / "arm-a" + _gcc(["-O2", "-o", str(arm_a), str(work_obj)], problems) + arm_c = Elf64(candidate) + + for label, (source, cflags, ldflags, owner) in _DAMAGE.items(): + src = tmp / f"{owner}.c" + src.write_text(source, encoding="utf-8") + obj, binary = tmp / f"{owner}.o", tmp / f"arm-b-{owner}" + _gcc(["-O2", *cflags, "-c", "-o", str(obj), str(src)], problems) + _gcc(["-O2", *ldflags, "-o", str(binary), str(work_obj), str(obj)], problems) + if not binary.is_file(): + problems.append(f"{label}: the damaged arm did not build") + continue + bad = Elf64(binary) + results = {"B1": pf.check_b1(bad), "B2": pf.check_b2(bad), + "B3": pf.check_b3(bad, arm_c), "B4": pf.check_b4(Elf64(arm_a), bad)} + if results[owner]["pass"]: + problems.append(f"{label}: {owner} accepted it — {results[owner]['why']}") + + # (3) Altered work, refused by B4 and by nothing else. + alt = tmp / "altered.c" + alt.write_text(_ALTERED_WORK, encoding="utf-8") + alt_obj, alt_bin = tmp / "altered.o", tmp / "arm-b-altered" + _gcc(["-O2", "-c", "-o", str(alt_obj), str(alt)], problems) + pad_obj = tmp / "healthy" / "pad.o" + if pad_obj.is_file(): + _gcc(["-O2", "-o", str(alt_bin), str(alt_obj), str(pad_obj)], problems) + if alt_bin.is_file(): + res = pf.check_b4(Elf64(arm_a), Elf64(alt_bin)) + if res["pass"]: + problems.append("B4 accepted an arm whose work loop uses a different " + "constant — the one thing it exists to refuse") + else: + problems.append("the healthy pad object was not kept, so the altered-work " + "arm could not be linked against it") + + if problems: + fail("round7-preflight", "; ".join(problems)) + else: + ok("round7-preflight", "B1-B4 pass on freshly built arms, and a dropped, " + "unmapped, mis-sized or work-altered arm B is each " + "refused by the check that owns it") + + +def _gcc(args: list[str], problems: list[str]) -> None: + r = subprocess.run(["gcc", *args], capture_output=True) + if r.returncode != 0: + problems.append(f"gcc {' '.join(args)} failed: " + + r.stderr.decode("utf-8", "replace")[:200]) + + +# --- the execution contract ------------------------------------------------ + + +def control_schedule() -> None: + """The order arms run in is fixed before the data, and replayable after it. + + The preregistration fixed how many sessions and halves and said nothing + about order. Run every A, then every B, then every C, and machine drift + becomes "the effect of the real binary" -- a result that would survive every + other check in this PR. + """ + problems = [] + blocks = sch.blocks() + halves = sch.planned_halves() + + # (1) The design, counted rather than described. + want_blocks = len(sch.REGIMES) * len(sch.REPETITION_COUNTS) * sch.SESSIONS + if len(blocks) != want_blocks: + problems.append(f"{len(blocks)} blocks, want {want_blocks} (2 regimes x 2 counts " + f"x {sch.SESSIONS} sessions)") + if len(halves) != want_blocks * 6: + problems.append(f"{len(halves)} halves, want {want_blocks * 6}") + cells = [b.key for b in blocks] + if len(set(cells)) != len(cells): + problems.append("a (regime, n, session) cell appears twice in the schedule") + expected_cells = {f"{r}|n{n}|s{s}" for r in sch.REGIMES + for n in sch.REPETITION_COUNTS for s in range(1, sch.SESSIONS + 1)} + if set(cells) != expected_cells: + problems.append(f"the schedule does not cover the design: missing " + f"{sorted(expected_cells - set(cells))[:3]}") + + # (2) Every block runs all three arms, with each arm's halves ADJACENT. + for b in blocks: + if sorted(b.arm_order) != sorted(sch.ARMS): + problems.append(f"block {b.key} runs {b.arm_order}, not all three arms") + break + seq = [(h.arm, h.half) for h in b.halves] + for i in range(0, len(seq), 2): + if seq[i][1] != "first" or seq[i + 1][1] != "second" or seq[i][0] != seq[i + 1][0]: + problems.append(f"block {b.key} splits an arm's halves: {seq}") + break + + # (3) Shuffled, not merely claimed to be. A constant arm order, or a block + # order equal to the generated order, would satisfy every check above. + if len({b.arm_order for b in blocks}) < 2: + problems.append(f"every block uses the same arm order {blocks[0].arm_order}: " + "the within-block shuffle is doing nothing, and drift would " + "align with arms exactly as if nothing were shuffled") + generated = [f"{r}|n{n}|s{s}" for r in sch.REGIMES + for n in sch.REPETITION_COUNTS for s in range(1, sch.SESSIONS + 1)] + if cells == generated: + problems.append("the block order is the generation order; the outer shuffle is " + "doing nothing and all of process-cold would run before all warm") + + # (4) Deterministic, and sensitive to the seed. A schedule nobody can replay + # is a fond memory; one that ignores its seed is not randomised at all. + if [b.key for b in sch.blocks()] != cells: + problems.append("two calls with the same seed produced different orders") + other = [b.key for b in sch.blocks(seed=sch.SCHEDULE_SEED ^ 0xFFFF)] + if other == cells: + problems.append("a different seed produced an identical order; the seed is " + "decorative") + + # (5) The seed is the Round 6 helper's, not a number I chose. Checked + # against the committed artifact rather than against the comment claiming it. + scales = json.loads((ROOT / "docs/evidence/round6/p022-263a-round6-scales.linux.json") + .read_text(encoding="utf-8")) + want_seed = int(scales["helper_sha256"][:16], 16) + if sch.SCHEDULE_SEED != want_seed: + problems.append(f"the seed 0x{sch.SCHEDULE_SEED:016x} is not the Round 6 helper's " + f"0x{want_seed:016x}: it is a number someone picked, and nothing " + "stops it being re-picked until the order looks tidy") + + # (6) The spawn count is computed from the plan, not quoted from prose. + spawns = sch.process_spawns(warmup_discards=2) + if spawns != 2640: + problems.append(f"the plan spawns {spawns} processes; the preregistration says " + "2640, and a quoted number nothing computes is one that drifts") + + if problems: + fail("round7-schedule", "; ".join(problems)) + else: + ok("round7-schedule", f"{len(blocks)} blocks x 6 halves = {len(halves)}, every " + f"(regime, n, session) exactly once, each arm's halves " + f"adjacent, {len({b.arm_order for b in blocks})} distinct arm " + f"orders, replayable from the seed and different without it; " + f"{spawns} planned spawns computed from the plan") + + +def control_execution_contract() -> None: + """Plan mode starts no clock, and the timed bytes are the preflighted bytes.""" + problems = [] + + # (1) The work binding reads Round 6's ladder rather than remembering it. + binding = rn.bind_work() + if binding.iterations != 460280: + problems.append(f"the 2 ms rung binds {binding.iterations} iterations, not 460280") + if not binding.helper_sha256: + problems.append("the binding carries no helper sha256, so arm A cannot be checked " + "against the ladder that gave it its iteration count") + # And it refuses a ladder that cannot supply one, rather than inventing a count. + with tempfile.TemporaryDirectory(prefix="round7-bind-") as td: + bad = Path(td) / "scales.json" + bad.write_text(json.dumps({"helper_sha256": "x", "rungs": [{"target_ms": 4}]}), + encoding="utf-8") + try: + rn.bind_work(bad) + except rn.ExecutionContractBreach: + pass + except Exception as exc: + # Reported, not raised. A control that dies here exits non-zero with + # no FAIL line, which reads as "caught" to a mutation runner counting + # exit codes and as nothing at all to a human reading CI. + problems.append(f"bind_work raised {type(exc).__name__} instead of refusing a " + f"ladder with no 2 ms rung: {exc}") + else: + problems.append("a ladder with no 2 ms rung was accepted; the arms' work would " + "be whatever the runner felt like") + + if sys.platform != "linux" or shutil.which("gcc") is None: + if problems: + fail("round7-execution-contract", "; ".join(problems)) + else: + ok("round7-execution-contract", f"the work binding reads 460280 from Round 6's " + f"ladder and refuses one without a 2 ms rung; " + f"the arm-identity half needs ELF arms and is " + f"skipped on {sys.platform}") + return + + candidate = ROOT / "rust/target/release/own-cli" + if not candidate.is_file(): + ok("round7-execution-contract", "the work binding holds; arm C is not built here, " + "so the identity freeze was not exercised") + return + + with tempfile.TemporaryDirectory(prefix="round7-exec-") as td: + tmp = Path(td) + # (2) Plan mode starts no clock. COUNTED, at the one function that can. + calls = {"n": 0} + real = rn.time_half + + def counting(*a: object, **k: object) -> dict[str, object]: + calls["n"] += 1 + return real(*a, **k) # type: ignore[arg-type] + + rn.time_half = counting # type: ignore[assignment] + try: + record = rn.run(candidate, tmp / "arms", measure=False) + finally: + rn.time_half = real # type: ignore[assignment] + if calls["n"]: + problems.append(f"plan mode called the timing function {calls['n']} times; it " + "must return before the clock is reachable at all") + if record["measurements"] is not None: + problems.append("plan mode produced measurements") + if record["stop_conditions"]: + problems.append(f"plan mode stopped: {record['stop_conditions']}") + + # (3) The freeze covers all three arms with sha256 AND byte length. + frozen = record["frozen_arms"] + if not isinstance(frozen, dict) or set(frozen) != {"A", "B", "C"}: + problems.append(f"the identity freeze covers {frozen} rather than all three arms") + else: + for role, row in frozen.items(): + if not row.get("sha256") or not row.get("file_bytes"): + problems.append(f"arm {role}'s freeze lacks a sha256 or a byte length") + + # (4) A byte changed after the freeze is refused. Actually changed, on + # disk, not simulated: this is the defect the whole transaction exists + # to prevent, and a fixture that edited a dict would prove nothing. + prepared = rn.prepare(candidate, tmp / "arms2") + arm_b = prepared.frozen["B"].path + arm_b.write_bytes(arm_b.read_bytes() + b"\x00") + try: + rn.verify_identities(prepared.frozen, "after a deliberate tamper") + except rn.ExecutionContractBreach as exc: + if "changed since the freeze" not in str(exc): + problems.append(f"the refusal does not say what happened: {exc}") + else: + problems.append("an arm rebuilt after the freeze was accepted for timing — the " + "preflight would prove properties of bytes that are gone") + # And a deleted arm, which is the rebuild-in-a-temp-dir case exactly. + arm_b.unlink() + try: + rn.verify_identities(prepared.frozen, "after a deliberate delete") + except rn.ExecutionContractBreach: + pass + else: + problems.append("a missing arm was accepted for timing") + + # (5) Arm A must BE the Round 6 helper, by sha, or the round stops. + # Both directions: the real arm accepted, a stand-in refused by name. + if not prepared.binding_ok: + problems.append(f"arm A does not match the Round 6 helper: " + f"{prepared.binding_problem}") + ok_, why_ = rn.check_binding("0" * 64, binding) + if ok_: + problems.append("a binary that is not the Round 6 helper was accepted as arm " + "A; 460280 iterations would then mean whatever that binary " + "happens to do, not 2 ms") + elif "do not re-derive" not in why_: + problems.append(f"the binding refusal does not forbid re-deriving a count: {why_}") + + if problems: + fail("round7-execution-contract", "; ".join(problems)) + else: + ok("round7-execution-contract", "plan mode calls the timing function zero times; " + "the freeze carries sha256 and byte length for all " + "three arms; a tampered or deleted arm is refused " + "by name; and arm A is byte-identical to Round 6's " + "2 ms helper") + + +class _FakeHarness: + """A harness whose interval returns exit codes I choose. + + The point of the control is the CHECK, not the clock: driving real processes + to exit 127 on demand would test the operating system. This returns rows + shaped exactly like `_run_once`'s so the check sees what it would really see. + """ + + def __init__(self, codes: list[int]) -> None: + self.codes = list(codes) + self.spawns = 0 + + def _run_once(self, argv: list[str], env: dict[str, str], + cwd: Path) -> dict[str, object]: + rc = self.codes[self.spawns] if self.spawns < len(self.codes) else 0 + self.spawns += 1 + return {"elapsed_ns": 1_000_000, "rc": rc, "peak_rss_bytes": 1024, + "rss_unavailable_reason": "", "accounting_unavailable_reason": ""} + + +def control_outcome_contract() -> None: + """A timed process must have done the work, and warmups count too. + + This is the Round 2 defect at one remove. Twelve cells once timed + `command-not-found` accurately and reproducibly, and the frozen instrument + grew an outcome layer because of it. Round 7 called `_run_once` directly and + walked straight past that layer: three perfectly identity-bound binaries + could have measured the wrong path with great precision. + """ + problems = [] + half = sch.Half("warm", 5, 1, "C", "first") + argv, env, cwd = ["x"], {}, ROOT + + # (1) The healthy direction: all spawns conforming, warmups included. + # Wrapped, because a mutation that changes arm C's expected code makes + # this raise, and a control that dies here exits non-zero with no FAIL + # line — which reads as "caught" to anything counting exit codes and as + # nothing at all to a human. That ghost has a season pass by now. + good = _FakeHarness([2] * 7) + try: + row = rn.time_half(good, half, argv, env, cwd, repetitions=5, discards=2) + except rn.OutcomeContractBreach as exc: + fail("round7-outcome-contract", + f"a healthy arm C half (every spawn exiting 2) was refused: {exc}") + return + if good.spawns != 7: + problems.append(f"{good.spawns} spawns for n=5 with 2 discards, want 7") + if len(row["samples"]) != 5: + problems.append(f"{len(row['samples'])} samples kept, want 5 (discards must not " + "be counted as measurements)") + if row.get("expected_rc") != 2: + problems.append("the half does not record which exit code it required") + + # (2) A stray SAMPLE is refused, and named. + for bad_rc in (1, 127): + h = _FakeHarness([2, 2, 2, bad_rc, 2, 2, 2]) + try: + rn.time_half(h, half, argv, env, cwd, repetitions=5, discards=2) + except rn.OutcomeContractBreach as exc: + s0 = exc.stray + if s0["spawn_kind"] != "sample" or s0["observed_rc"] != bad_rc: + problems.append(f"a sample exiting {bad_rc} was recorded as {s0}") + for field in ("block", "arm", "half", "spawn_kind", "index", "observed_rc"): + if field not in s0: + problems.append(f"the stray record omits {field!r}: " + "'something exited wrong somewhere' is not a record") + # And nothing kept spawning after the breach was known. + if h.spawns != 4: + problems.append(f"{h.spawns} spawns after a breach at spawn 4; the half " + "kept running processes whose numbers nobody may use") + else: + problems.append(f"arm C exiting {bad_rc} was accepted as a calibration " + "sample — exactly the shape that timed 12 " + "command-not-found cells and called them reproduced") + + # (3) A stray WARMUP is refused too. Its numbers are discarded; the evidence + # that the process is broken is not. + h = _FakeHarness([2, 127, 2, 2, 2, 2, 2]) + try: + rn.time_half(h, half, argv, env, cwd, repetitions=5, discards=2) + except rn.OutcomeContractBreach as exc: + if exc.stray["spawn_kind"] != "warmup" or exc.stray["index"] != 1: + problems.append(f"the failing warmup was misrecorded: {exc.stray}") + else: + problems.append("a warmup discard that failed was ignored; a discarded iteration " + "still proves the process is broken") + + # (4) The arms expect DIFFERENT codes, so a check keyed on one constant is + # wrong for two of the three. A/B must exit 0, C must exit 2. + if rn.EXPECTED_RC != {"A": 0, "B": 0, "C": 2}: + problems.append(f"the arms' expected exit codes are {rn.EXPECTED_RC}") + for arm, good_rc, bad_rc in (("A", 0, 2), ("B", 0, 1), ("C", 2, 0)): + hh = sch.Half("process-cold", 5, 1, arm, "second") + ok_h = _FakeHarness([good_rc] * 5) + try: + rn.time_half(ok_h, hh, argv, env, cwd, repetitions=5, discards=0) + except rn.OutcomeContractBreach as exc: + problems.append(f"arm {arm} exiting {good_rc} was refused: {exc}") + except Exception as exc: + problems.append(f"arm {arm} exiting {good_rc} raised " + f"{type(exc).__name__}: {exc}") + bad_h = _FakeHarness([bad_rc] * 5) + try: + rn.time_half(bad_h, hh, argv, env, cwd, repetitions=5, discards=0) + except rn.OutcomeContractBreach: + pass + else: + problems.append(f"arm {arm} exiting {bad_rc} was accepted; {arm} must exit " + f"{good_rc}") + + # (5) Arm C's untimed contract is the INSTRUMENT's, not a third restatement. + if sys.platform == "linux" and shutil.which("gcc"): + candidate = ROOT / "rust/target/release/own-cli" + if candidate.is_file(): + with tempfile.TemporaryDirectory(prefix="round7-oc-") as td: + prepared = rn.prepare(candidate, Path(td) / "arms") + pre = prepared.outcome + if not pre.ran or not pre.all_passed: + problems.append(f"the untimed outcome preflight refused a healthy " + f"build: {pre.failed} " + f"{[pre.arms[a].why for a in pre.failed]}") + elif "core-usage" not in pre.arms["C"].contract: + problems.append(f"arm C is not verified through the instrument's own " + f"rung: {pre.arms['C'].contract}") + + # A stand-in that exits 2 and prints NOTHING. Exit 2 is the + # right code for the wrong reason, which is the whole argument + # for checking evidence as well. Built, not simulated. + stub = Path(td) / "not-really-own-cli" + stub.write_text("#!/bin/sh\nexit 2\n", encoding="utf-8") + stub.chmod(0o755) + faked = {**prepared.frozen, "C": rn._identity("C", stub)} + pre_bad = rn.outcome_preflight(faked, prepared.binding) + if pre_bad.arms["C"].passed: + problems.append("a binary that exits 2 and prints nothing passed as " + "arm C; the runner is reading the exit code and not " + "the usage-help evidence, so any other failure " + "exiting 2 would be timed as core-usage") + elif pre_bad.all_passed: + problems.append("arm C failed its contract but the preflight still " + "reported all_passed") + + # And a failed preflight must STOP the round, not merely be noted. + stopped = rn.Prepared( + binding=prepared.binding, build=prepared.build, + checks=prepared.checks, preflight_failed=[], + frozen=prepared.frozen, binding_ok=True, binding_problem="", + arm_c_mapped_bytes=prepared.arm_c_mapped_bytes, outcome=pre_bad) + if not stopped.stop_conditions: + problems.append("a refused outcome preflight produced no stop " + "condition; the round would time the arms anyway") + elif not any("C" in c for c in stopped.stop_conditions): + problems.append(f"the stop condition does not name the refused arm: " + f"{stopped.stop_conditions}") + # And exit 2 alone must NOT be enough: the usage-help contract + # also requires stdout to name the subcommand and stderr empty. + bad_out = pb._evidence_problem("usage-help", "", "") + bad_err = pb._evidence_problem("usage-help", "ownir", "boom") + if not bad_out: + problems.append("the usage-help contract accepts empty stdout, so a " + "different failure exiting 2 would pass as arm C") + if not bad_err: + problems.append("the usage-help contract accepts a non-empty stderr") + if pb._evidence_problem("usage-help", "ownir usage", ""): + problems.append("the usage-help contract refuses a healthy refusal") + # If arm C is not built here the untimed half simply does not run; the + # rc checks above are platform-independent and already did. + + if problems: + fail("round7-outcome-contract", "; ".join(problems)) + else: + ok("round7-outcome-contract", "every spawn is checked against its arm's exit code " + "(A/B 0, C 2), warmup discards included; a stray " + "sample or warmup is refused and recorded with arm, " + "block, half, kind and index; and arm C's untimed " + "contract is the instrument's own core-usage rung, " + "where exit 2 alone is not sufficient") + + +def control_durable_refusal() -> None: + """An invalid run writes a black box. Checked from OUTSIDE, on the filesystem. + + `round7-outcome-contract` proves the runner refuses. It proves it by reading + the exception object, which is the same mistake as scoring a mutation by its + exit code: the refusal happened, and nothing survived to say so. Until this + control existed, a stray exit on half 239 produced a traceback, no `--out` + file, and nothing to investigate. + + So this one never looks at an exception. It drives `main()` and then reads + the filesystem: the file exists, the exit code is non-zero, the record says + `run_valid: false`, `measurements` is null, and the abort names the exact + spawn or the exact arm. + """ + if sys.platform != "linux" or shutil.which("gcc") is None: + ok("round7-durable-refusal", f"skipped on {sys.platform}: driving the runner " + "needs the ELF arms it builds with gcc") + return + candidate = ROOT / "rust/target/release/own-cli" + if not candidate.is_file(): + ok("round7-durable-refusal", "arm C is not built here, so the runner could not " + "be driven to a refusal") + return + + problems = [] + + def drive(out: Path, build: Path) -> int: + """Run the runner, turning an escaping exception into a finding. + + Without this catch, the exact defect this control exists to detect -- + a breach escaping `run()` -- kills the control instead of being reported + by it. That is the fifth appearance of crash-instead-of-finding in this + PR, and the first inside the control written to catch that very shape. + Returning 1 lets the checks below report the missing file as the finding + it is. + """ + argv = ["runner.py", "--candidate", str(candidate), "--measure", + "--build-dir", str(build), "--out", str(out)] + real_argv = sys.argv + sys.argv = argv + try: + return rn.main() + except Exception as exc: + problems.append(f"the runner let {type(exc).__name__} escape instead of " + f"recording it: {str(exc)[:120]}") + return 1 + finally: + sys.argv = real_argv + + def check(label: str, out: Path, code: int, want_kind: str, + must_name: list[str]) -> None: + if not out.is_file(): + problems.append(f"{label}: the runner refused and wrote NO record — the " + "refusal is a traceback and nothing else") + return + if code == 0: + problems.append(f"{label}: exit code 0 for an invalid run") + rec = json.loads(out.read_text(encoding="utf-8")) + if rec.get("run_valid") is not False: + problems.append(f"{label}: run_valid is {rec.get('run_valid')!r}, not False") + if rec.get("measurements") is not None: + problems.append(f"{label}: an invalid run carries measurements") + abort = rec.get("abort") + if not isinstance(abort, dict): + problems.append(f"{label}: no abort block") + return + if abort.get("kind") != want_kind: + problems.append(f"{label}: abort kind {abort.get('kind')!r}, want {want_kind!r}") + missing = [k for k in must_name if k not in abort] + if missing: + problems.append(f"{label}: the abort does not name {missing}; " + f"it says only {sorted(abort)}") + if "verdict" not in rec or "INVALID" not in str(rec["verdict"]): + problems.append(f"{label}: the verdict does not say INVALID") + for key in ("timing", "classification", "outcome"): + if key in rec and key not in ("outcome_preflight",): + problems.append(f"{label}: an invalid run carries {key!r}") + + with tempfile.TemporaryDirectory(prefix="round7-durable-") as td: + tmp = Path(td) + + # (1) A stray exit code. time_half is replaced so NO real timing happens: + # the point is the refusal path, not the clock, and no Round 7 + # measurement is authorised. + out1 = tmp / "stray.json" + real_time_half = rn.time_half + + def raising(*a: object, **k: object) -> dict[str, object]: + raise rn.OutcomeContractBreach( + {"block": "warm|n5|s3", "arm": "C", "half": "second", + "spawn_kind": "sample", "index": 4, "observed_rc": 127, + "expected_rc": 2}) + + rn.time_half = raising # type: ignore[assignment] + try: + code1 = drive(out1, tmp / "arms1") + finally: + rn.time_half = real_time_half # type: ignore[assignment] + check("stray exit", out1, code1, "outcome-contract", + ["arm", "block", "half", "spawn_kind", "index", "observed_rc", "expected_rc"]) + + # (2) Identity drift mid-run, DETECTED for real: the arm's bytes are + # actually changed on disk and the real verifier notices. + out2 = tmp / "drift.json" + real_verify = rn.verify_identities + state = {"tampered": False} + + def tamper_then_verify(frozen: dict[str, object], when: str) -> None: + if not state["tampered"]: + state["tampered"] = True + arm_b = frozen["B"].path # type: ignore[attr-defined] + arm_b.write_bytes(arm_b.read_bytes() + b"\x00") + real_verify(frozen, when) # type: ignore[arg-type] + + rn.verify_identities = tamper_then_verify # type: ignore[assignment] + try: + code2 = drive(out2, tmp / "arms2") + finally: + rn.verify_identities = real_verify # type: ignore[assignment] + check("identity drift", out2, code2, "identity-contract", + ["arm", "when", "expected_sha256", "observed_sha256"]) + + # (3) The healthy path still reports itself valid, or this control would + # pass just as well against a runner that called everything invalid. + out3 = tmp / "plan.json" + argv = ["runner.py", "--candidate", str(candidate), "--plan", + "--build-dir", str(tmp / "arms3"), "--out", str(out3)] + real_argv = sys.argv + sys.argv = argv + try: + code3 = rn.main() + finally: + sys.argv = real_argv + if code3 != 0 or not out3.is_file(): + problems.append(f"a healthy plan run exited {code3} or wrote no record") + else: + rec3 = json.loads(out3.read_text(encoding="utf-8")) + if rec3.get("run_valid") is not True: + problems.append(f"a healthy plan run reports run_valid " + f"{rec3.get('run_valid')!r}") + if "abort" in rec3: + problems.append("a healthy plan run carries an abort block") + + if problems: + fail("round7-durable-refusal", "; ".join(problems)) + else: + ok("round7-durable-refusal", "a stray exit and a real mid-run identity drift each " + "leave a written record with run_valid false, null " + "measurements, and an abort naming the exact spawn or " + "arm; a healthy run still reports itself valid") + + +def _synthetic(by_regime: dict[str, dict[int, tuple[float, float, float]]] + ) -> dict[str, object]: + """A dataset whose D(arm, n, regime) is exactly the triple asked for. + + Every sample in a half carries the same value, so median(half) is that value + and |median(second) - median(first)| is the requested drift in every session. + A control that fed the readout real numbers could only check that it did + something; this checks that it did the preregistered thing. + """ + measurements: list[dict[str, object]] = [] + for regime, by_n in by_regime.items(): + for n, triple in by_n.items(): + for arm, drift in zip(ro.ARMS, triple, strict=True): + for session in range(1, ro.SESSIONS + 1): + for half in ro.HALVES: + value = 1_000_000.0 + (drift if half == "second" else 0.0) + measurements.append({ + "half": f"{regime}|n{n}|s{session}|{arm}|{half}", + "samples": [{"elapsed_ns": value, "rc": ro.EXPECTED_RC[arm], + "cpu_user_ns": 0, "cpu_system_ns": 0, + "minor_faults": 0, "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0} + for _ in range(n)]}) + return {"run_valid": True, "measurements": measurements} + + +def control_readout() -> None: + """The reading computes the preregistered D and nothing else. + + Two halves. First, synthetic datasets whose drift triples are known exactly, + so the rule that fires is known in advance -- this caught the author's own + arithmetic before the measurement pass ran, the third time in this PR that a + hand-checked boundary was wrong. Second, and the one that matters after the + fact: the committed reading must be REPRODUCIBLE from the committed dataset. + A reading nobody can recompute is a reading that has to be trusted, and this + round exists precisely because trusting a reading is not a method. + """ + problems = [] + + # Each triple holds at both counts in both regimes, so the outcome is the + # rule that fires. The comments quote the clause that decides. + cases = [ + ((1.0, 3.0, 6.0), "P3"), # B >= 3A and C >= 2B + ((1.0, 1.0, 4.0), "P2"), # B <= 1.5A and C >= 3A + ((1.0, 3.0, 3.0), "P1"), # C > 1.5A, B >= 3A, (2/3)B <= C <= 1.5B + ((1.0, 3.0, 1.4), "P4"), # C <= 1.5A + ((0.0, 3.0, 4.0), "P5"), # the zero-A guard + ((1.0, 2.0, 2.0), "P5"), # no rule fires + ] + for triple, want in cases: + record = _synthetic({r: dict.fromkeys(cl.REPETITION_COUNTS, triple) + for r in cl.REGIMES}) + try: + reading = ro.read(record) + except Exception as exc: + problems.append(f"{triple} raised {type(exc).__name__}: {exc}") + continue + for regime in cl.REGIMES: + got = reading["outcome"]["per_regime"][regime]["outcome"] # type: ignore[index] + if got != want: + problems.append(f"D={triple} in {regime} read as {got}, want {want}") + # The mechanism table is applied only after an outcome fires. P4 and P5 + # fire no rule and name no elevated arm, so an attribution there would be + # an analysis the preregistration does not license. + applied = reading["mechanism_attribution"][cl.REGIMES[0]]["applied"] # type: ignore[index] + if applied is not bool(ro.ELEVATED_BY_OUTCOME[want]): + problems.append(f"{want}: attribution applied={applied}, " + f"want {bool(ro.ELEVATED_BY_OUTCOME[want])}") + + # Disagreement across counts inside one regime is P5; a cold/warm difference + # is a reported split, not P5. + split = _synthetic({"process-cold": {5: (1.0, 3.0, 6.0), 15: (1.0, 1.0, 4.0)}, + "warm": dict.fromkeys(cl.REPETITION_COUNTS, (1.0, 1.0, 4.0))}) + try: + reading = ro.read(split) + except Exception as exc: + # A reading that dies here is a traceback, not a finding. This control + # exists to report, and a control that crashes reports nothing. + problems.append(f"the split case raised {type(exc).__name__}: {exc}") + else: + if reading["outcome"]["per_regime"]["process-cold"]["outcome"] != "P5": # type: ignore[index] + problems.append("P3 at n=5 and P2 at n=15 did not become P5") + if reading["outcome"]["per_regime"]["warm"]["outcome"] != "P2": # type: ignore[index] + problems.append("warm did not classify P2") + if not reading["outcome"]["regime_split"]: # type: ignore[index] + problems.append("a cold/warm difference was not reported as a split") + + # The zero-versus-zero hole. Every mechanism rule is a ratio against a + # quantity that can itself be zero, and `0 >= 2 * 0` is true, so a cell + # where NOTHING moved once fired all three mechanisms at once: a confident + # attribution of a drift that does not exist. + still = {} + for regime in cl.REGIMES: + for n in cl.REPETITION_COUNTS: + for arm in ro.ARMS: + for session in range(1, ro.SESSIONS + 1): + for half in ro.HALVES: + still[(regime, n, session, arm, half)] = [{ + "elapsed_ns": 1_000_000.0, "rc": ro.EXPECTED_RC[arm], + "cpu_user_ns": 0, "cpu_system_ns": 0, + "minor_faults": 0, "major_faults": 0, + "voluntary_context_switches": 0, + "involuntary_context_switches": 0}] + try: + null_row = ro.attribution(still, cl.REGIMES[0], cl.REPETITION_COUNTS[0], "C") + except Exception as exc: + problems.append(f"the null-evidence attribution raised {type(exc).__name__}: {exc}") + else: + if null_row["fired"]: + problems.append("a cell where nothing moved attributed " + f"{null_row['fired']} -- every delta is zero and " + "0 >= 2 * 0 is true, so the rules fired on no evidence") + + # The case that actually exercises the two RATIFIED guards: wall time moved + # but not one kernel counter did. The precondition above does not fire here, + # so `ctx >= 2 * a_ctx` and `faults >= 2 * a_faults` are reached with both + # sides at zero. Without `> 0` they report scheduler AND faults/mapping -- + # the exact opposite of the truth, which is that the drift is visible in + # wall time and in none of the accounting the kernel offers. + # + # The first version of this control missed all of that: its only degenerate + # case had zero wall drift, so the precondition returned first and the two + # guards were never reached. Three mutations removing them came back green. + wall_only = {k: [dict(r) for r in v] for k, v in still.items()} + for key, rows in wall_only.items(): + if key[3] == "C" and key[4] == "second": + for r in rows: + r["elapsed_ns"] = 3_000_000.0 + try: + wall_row = ro.attribution(wall_only, cl.REGIMES[0], cl.REPETITION_COUNTS[0], "C") + except Exception as exc: + problems.append(f"the wall-only attribution raised {type(exc).__name__}: {exc}") + else: + if wall_row["fired"]: + problems.append( + f"wall time moved and no kernel counter did, yet the table attributed " + f"{wall_row['fired']}; both ratios compare zero against zero, and " + "0 >= 2 * 0 is true") + + # ... and a real signal must still fire, or the guards above would pass just + # as well against a mechanism table that had been switched off entirely. + moved = {k: [dict(r) for r in v] for k, v in still.items()} + for (_regime, _n, _session, arm, half), rows in moved.items(): + if arm == "C" and half == "second": + for r in rows: + r["elapsed_ns"] = 3_000_000.0 + r["minor_faults"] = 500 + try: + live_row = ro.attribution(moved, cl.REGIMES[0], cl.REPETITION_COUNTS[0], "C") + except Exception as exc: + problems.append(f"the live-signal attribution raised {type(exc).__name__}: {exc}") + else: + if "faults" not in live_row["fired"]: + problems.append(f"a real fault signal did not fire: {live_row['fired']} " + f"from {live_row['median_abs_delta']}") + + # Arm A must be the reference it claims to be. Above, arm A has zero faults, + # so `>= 2 * a_faults` holds however the rule is written; a mutation dropping + # the reference entirely came back green. Here arm A faults MORE than half of + # what arm C does, so the ratio is what decides and the rule must stay shut. + baseline = {k: [dict(r) for r in v] for k, v in still.items()} + for key, rows in baseline.items(): + if key[4] == "second": + for r in rows: + r["elapsed_ns"] = 3_000_000.0 + if key[3] == "C": + r["minor_faults"] = 500 + elif key[3] == "A": + r["minor_faults"] = 400 # C is 500, so C < 2 x A + try: + ref_row = ro.attribution(baseline, cl.REGIMES[0], cl.REPETITION_COUNTS[0], "C") + except Exception as exc: + problems.append(f"the arm-A-reference attribution raised {type(exc).__name__}: {exc}") + else: + if "faults" in ref_row["fired"]: + problems.append( + f"arm C's fault delta {ref_row['median_abs_delta']['faults']} is below " + f"twice arm A's {ref_row['arm_a_reference']['faults']}, yet faults/mapping " + "fired; the rule is not consulting arm A as its reference") + + # Fail-closed, five ways. Each would otherwise produce a median over + # whatever survived and call it the preregistered D. + healthy = _synthetic({r: dict.fromkeys(cl.REPETITION_COUNTS, (1.0, 3.0, 6.0)) + for r in cl.REGIMES}) + refusals: list[tuple[str, dict[str, object]]] = [] + + invalid = {"run_valid": False, "measurements": None, "abort": {"kind": "outcome-contract"}} + refusals.append(("an invalid run", invalid)) + + # An invalid run whose halves are nonetheless complete and well-formed. This + # isolates the run_valid gate: the case above is refused by the missing + # measurements list whether that gate exists or not, so on its own it proves + # nothing about the gate it appears to test. + invalid_but_complete = json.loads(json.dumps(healthy)) + invalid_but_complete["run_valid"] = False + invalid_but_complete["abort"] = {"kind": "identity-contract", "arm": "B"} + refusals.append(("an invalid run carrying a complete set of halves", invalid_but_complete)) + + stray = json.loads(json.dumps(healthy)) + stray["measurements"][0]["samples"][0]["rc"] = 127 + refusals.append(("a stray exit code", stray)) + + missing = json.loads(json.dumps(healthy)) + missing["measurements"].pop() + refusals.append(("a missing half", missing)) + + short = json.loads(json.dumps(healthy)) + short["measurements"][0]["samples"].pop() + refusals.append(("a half with too few samples", short)) + + for label, bad in refusals: + try: + ro.read(bad) + except ro.ReadoutRefused: + pass + except Exception as exc: + problems.append(f"{label} raised {type(exc).__name__} instead of " + f"ReadoutRefused: {exc}") + else: + problems.append(f"{label} was read instead of refused") + + # And the part that cannot be faked: the committed reading must come back + # out of the committed dataset. + dataset = ROOT / "docs/evidence/round7/p022-263a-round7-dataset.linux.json" + committed = ROOT / "docs/evidence/round7/p022-263a-round7-reading.linux.json" + if dataset.is_file() and committed.is_file(): + # The spawn accounting, computed rather than quoted, and run BEFORE the + # reproduction check so it cannot end up inside a branch that only fires + # on failure. It did exactly that on the first attempt -- dead code under + # an `except`, with the control's success message still claiming it had + # verified 2400 samples. An assertion that sounds like a check, written + # into the edit whose whole purpose was to remove one. + # + # The retained samples and the warmup discards are DIFFERENT populations. + # "2640 spawns, all exit codes as contracted" invites the reader to think + # 2640 rows were kept. 2400 were. + data = json.loads(dataset.read_text(encoding="utf-8")) + halves = data["measurements"] + retained = sum(len(h["samples"]) for h in halves) + warm_halves = sum(1 for h in halves if h["half"].startswith("warm")) + codes: dict[int, int] = {} + for h in halves: + for row in h["samples"]: + codes[int(row["rc"])] = codes.get(int(row["rc"]), 0) + 1 + # The literals here are the RATIFIED design, not the live constants. + # A first attempt compared rn.WARMUP_DISCARDS against a schedule + # computed from rn.WARMUP_DISCARDS, so mutating that constant moved + # both sides together and the check stayed green: a check reading a + # proxy for the thing, which is the defect this whole PR is about. + if rn.WARMUP_DISCARDS != 2: + problems.append(f"the warmup discard count is {rn.WARMUP_DISCARDS}; the " + "ratified design fixes it at 2 and it is not a knob") + if retained != 2400: + problems.append(f"{retained} retained samples, not the 2400 the design " + "fixes (3 arms x 2 counts x 10 sessions x 2 halves x " + "(5 + 15) per regime, both regimes)") + planned = data.get("planned_process_spawns") + if retained + warm_halves * 2 != planned: + problems.append(f"retained {retained} + {warm_halves * 2} warmup discards " + f"does not equal the {planned} spawns this very dataset " + "recorded as planned") + if codes != {0: 1600, 2: 800}: + problems.append(f"retained exit codes are {codes}, not " + "{0: 1600, 2: 800}") + + try: + recomputed = ro.read(json.loads(dataset.read_text(encoding="utf-8"))) + except Exception as exc: + problems.append(f"the committed dataset would not read: " + f"{type(exc).__name__}: {exc}") + else: + # Compared as SERIALISED json, which is what was committed: read() + # keys repetition counts by int and json keys them by string, so an + # object-to-parsed-object comparison would report a difference that + # exists only in Python and miss any that does not. + got = json.loads(json.dumps(recomputed)) + want = json.loads(committed.read_text(encoding="utf-8")) + if got != want: + differing = sorted(k for k in set(got) | set(want) + if got.get(k) != want.get(k)) + problems.append("the committed reading is NOT what the committed dataset " + f"produces; sections differing: {differing}") + else: + problems.append("the Round 7 dataset or reading is missing, so the reading " + "could not be recomputed from the evidence it claims to read") + + if problems: + fail("round7-readout", "; ".join(problems)) + else: + ok("round7-readout", "D is the median across sessions of |median(second half) - " + "median(first half)| on elapsed_ns; every ratified rule fires " + "on a triple built to trigger it; the mechanism table stays " + "shut on P4 and P5; five malformed datasets are refused; the " + "committed dataset holds 2400 retained samples (1600 rc 0, " + "800 rc 2) which with 240 warmup discards accounts for every " + "planned spawn; a cell where nothing moved attributes no " + "mechanism while a real fault signal still fires; and the " + "committed reading is reproduced exactly from the committed " + "dataset") + + +def run() -> int: + control_outcome_exclusivity() + control_zero_guard() + control_boundaries() + control_regime_reading() + control_preflight() + control_schedule() + control_execution_contract() + control_outcome_contract() + control_durable_refusal() + control_readout() + print() + print(f"round 7 apparatus controls: {len(_PASSES)} passed, {len(_FAILURES)} failed") + return 1 if _FAILURES else 0 + + +if __name__ == "__main__": + sys.exit(run()) diff --git a/tests/test_step7_envcapture.py b/tests/test_step7_envcapture.py new file mode 100644 index 00000000..4230ba16 --- /dev/null +++ b/tests/test_step7_envcapture.py @@ -0,0 +1,565 @@ +#!/usr/bin/env python3 +"""#263-A step 7 — controls on the measurement-free environment identity manifest. + +The capture tool exists so the execution binding can name two real machines. It +must therefore be provably free of clocks, and its "unknown" must never be able +to arrive dressed as a value. + + envcapture-schema the declared key set, enforced both ways + envcapture-field-contract observed/unavailable, with no third state + envcapture-identity-split provenance can never become identity + envcapture-assigned-id an owner-assigned id cannot be 'unavailable' + envcapture-drift provenance moves freely; identity never does + envcapture-no-measurement no clock, no resource observation, by AST + envcapture-reason-fits-platform an 'unavailable' reason names THIS platform + envcapture-windows-fixture the schema holds off Linux; the capture path does not + envcapture-frozen-untouched this addition moved none of the three frozen digests + envcapture-ci-provenance a CI-taken manifest says so and cannot hide it + +`envcapture-no-measurement` walks the AST rather than the text, because this +module's own docstring names `perf_counter` and `wait4` to say it does not use +them. A text scan would read the prose and call that a finding, which is the +same defect as a check reading a proxy for the thing it checks. + +`envcapture-frozen-untouched` is the one that protects everything already +accepted: adding a file under `scripts/calibration/` or `scripts/training/` +would move a digest that steps 4, 5 and 6 are bound to. + +Failures print `FAIL[]: `; nothing stops at the first one. + +Run: python tests/test_step7_envcapture.py +""" + +from __future__ import annotations + +import ast +import copy +import json +import os +import subprocess +import sys +from collections.abc import Callable +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts")) +sys.path.insert(0, str(ROOT / "scripts" / "step7")) +sys.path.insert(0, str(ROOT / "tests")) + +import envcapture as ec # noqa: E402 +import perf_baseline as pb # noqa: E402 +from test_calibration_freeze import implementation_digest # noqa: E402 + +SOURCE = ROOT / "scripts" / "step7" / "envcapture.py" +FREEZE = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-policy-freeze.json" +PREREG = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-training-preregistration.json" + +_FAILURES: list[tuple[str, str]] = [] +_PASSES: list[str] = [] + + +def fail(check: str, detail: str) -> None: + _FAILURES.append((check, detail)) + print(f"FAIL[{check}]: {detail}") + + +def ok(check: str, detail: str = "") -> None: + _PASSES.append(check) + print(f"ok[{check}]: {detail}" if detail else f"ok[{check}]") + + +def _live() -> dict[str, object]: + return ec.capture("control-fixture-not-a-measurement-environment") + + +# --- the declared shape ----------------------------------------------------- + + +def control_schema() -> None: + manifest = _live() + problems = ec.validate(manifest) + if problems: + fail("envcapture-schema", f"the live capture does not validate: {'; '.join(problems)}") + return + + # Driven both ways: an extra key and a missing key must each be refused. + extra = copy.deepcopy(manifest) + extra["identity"]["cpu_temperature"] = ec.observed("41C") # type: ignore[index] + if not ec.validate(extra): + fail("envcapture-schema", "an undeclared identity field was accepted") + return + missing = copy.deepcopy(manifest) + del missing["identity"]["kernel"] # type: ignore[union-attr] + if not ec.validate(missing): + fail("envcapture-schema", "a missing identity field was accepted as if absent meant fine") + return + wrong_schema = copy.deepcopy(manifest) + wrong_schema["schema"] = "something-else" + if not ec.validate(wrong_schema): + fail("envcapture-schema", "a foreign schema name was accepted") + return + ok("envcapture-schema", + f"{len(ec.IDENTITY_FIELDS)} identity and {len(ec.PROVENANCE_FIELDS)} provenance fields, " + "with an extra key, a missing key and a foreign schema each refused") + + +def control_field_contract() -> None: + """Zero, empty and boolean are the three ways 'unknown' sneaks in as a value.""" + cases: tuple[tuple[str, object], ...] = ( + ("empty string", {"status": "observed", "value": ""}), + ("whitespace", {"status": "observed", "value": " "}), + ("zero count", {"status": "observed", "value": 0}), + ("negative count", {"status": "observed", "value": -1}), + ("bare true", {"status": "observed", "value": True}), + ("bare false", {"status": "observed", "value": False}), + ("null value", {"status": "observed", "value": None}), + ("observed with no value", {"status": "observed"}), + ("observed carrying a reason", {"status": "observed", "value": "x", "reason": "y"}), + ("unavailable with no reason", {"status": "unavailable"}), + ("unavailable with empty reason", {"status": "unavailable", "reason": ""}), + ("unavailable carrying a value", {"status": "unavailable", "reason": "r", "value": "v"}), + ("unknown status", {"status": "probably", "value": "x"}), + ("no status at all", {"value": "x"}), + ("not an object", "just a string"), + ) + missed = [name for name, field in cases if not ec.field_problems("identity.cpu_model", field)] + if missed: + fail("envcapture-field-contract", + f"accepted as a valid field: {', '.join(missed)}") + return + good = ec.field_problems("identity.cpu_model", ec.observed("Xeon")) + good += ec.field_problems("identity.power_policy", ec.unavailable("no cpufreq on this host")) + if good: + fail("envcapture-field-contract", f"refused a well-formed field: {'; '.join(good)}") + return + ok("envcapture-field-contract", + f"{len(cases)} malformed fields refused, including bare true and false, since a bool " + "IS an int in Python and an unguarded numeric test would have taken them") + + +def control_identity_split() -> None: + overlap = set(ec.IDENTITY_FIELDS) & set(ec.PROVENANCE_FIELDS) + if overlap: + fail("envcapture-identity-split", f"declared in both classes: {sorted(overlap)}") + return + for name in ("runner_name", "workflow_run_id", "job_id", "timestamp_utc", "ci"): + if name in ec.IDENTITY_FIELDS: + fail("envcapture-identity-split", + f"{name} is identity-bearing, which the owner's ruling forbids") + return + smuggled = copy.deepcopy(_live()) + smuggled["identity"]["runner_name"] = ec.observed("GitHub Actions 7") # type: ignore[index] + if not ec.validate(smuggled): + fail("envcapture-identity-split", "runner_name was accepted as an identity field") + return + ok("envcapture-identity-split", + "runner name, workflow and job ids, timestamp and the CI flag are provenance only; " + "promoting runner_name into identity is refused") + + +def control_assigned_id() -> None: + unavailable_id = {"status": "unavailable", "reason": "nobody told us"} + if not ec.field_problems("environment_id", unavailable_id): + fail("envcapture-assigned-id", + "environment_id was allowed to be unavailable, so a binding could name no environment") + return + refused = [] + for bad in ("", " "): + try: + ec.capture(bad) + except ec.CaptureRefused: + refused.append(bad) + except Exception as exc: # a crash is not a refusal + fail("envcapture-assigned-id", + f"capture({bad!r}) raised {type(exc).__name__} instead of refusing by name") + return + if len(refused) != 2: + fail("envcapture-assigned-id", "capture() accepted an empty environment_id") + return + ok("envcapture-assigned-id", + "an owner-assigned id cannot be 'unavailable' and an empty one is refused by name, " + "not by crash") + + +def control_drift() -> None: + first = _live() + # A new allocation: every provenance field differs, nothing about the machine did. + reallocated = copy.deepcopy(first) + reallocated["provenance"] = { # type: ignore[index] + "timestamp_utc": "2030-01-01T00:00:00+00:00", + "runner_name": "a completely different runner", + "workflow_run_id": "999999", + "job_id": "another-job", + "ci": True, + } + drift = ec.identity_drift(first, reallocated) + if drift: + fail("envcapture-drift", + f"a new runner allocation was read as environment drift: {drift}") + return + + moved = copy.deepcopy(first) + moved["identity"]["cpu_model"] = ec.observed("a different CPU") # type: ignore[index] + if ec.identity_drift(first, moved) != ("cpu_model",): + fail("envcapture-drift", "a changed cpu_model was not reported as drift") + return + + went_dark = copy.deepcopy(first) + went_dark["identity"]["rustc"] = ec.unavailable("toolchain removed") # type: ignore[index] + if "rustc" not in ec.identity_drift(first, went_dark): + fail("envcapture-drift", + "a field that went from observed to unavailable was not drift, so an " + "environment could go dark between runs unnoticed") + return + + reworded = copy.deepcopy(first) + reworded["identity"]["power_policy"] = ec.unavailable("a different reason") # type: ignore[index] + if "power_policy" not in ec.identity_drift(first, reworded): + fail("envcapture-drift", "a changed unavailable reason was not reported as drift") + return + + try: + ec.identity_drift({}, first) + except ec.CaptureRefused: + pass + except Exception as exc: # a crash is not a refusal + fail("envcapture-drift", + f"comparing a manifest with no identity raised {type(exc).__name__}, not a refusal") + return + else: + fail("envcapture-drift", "a manifest with no identity object compared as if it had one") + return + ok("envcapture-drift", + "a whole new runner allocation is not drift; a changed CPU, a field going dark and a " + "reworded reason all are; an identity-less manifest is refused by name") + + +# --- no clock, proved by reading the code rather than the prose ------------- + + +FORBIDDEN_ATTRS = frozenset({ + "perf_counter", "perf_counter_ns", "monotonic", "monotonic_ns", + "process_time", "process_time_ns", "thread_time", "thread_time_ns", + "clock_gettime", "clock_gettime_ns", "wait4", "wait3", "getrusage", "times", +}) +FORBIDDEN_MODULES = frozenset({"time", "timeit", "resource"}) + + +def measurement_capabilities(tree: ast.AST) -> tuple[str, ...]: + """Written once, used twice: on the real module and on a mutated copy. + + Walks the AST, so the docstring naming these APIs in order to disclaim them + is not mistaken for using them. + """ + found: list[str] = [] + for node in ast.walk(tree): + if isinstance(node, ast.Import): + found += [f"import {a.name}" for a in node.names + if a.name.split(".")[0] in FORBIDDEN_MODULES] + elif isinstance(node, ast.ImportFrom): + root = (node.module or "").split(".")[0] + if root in FORBIDDEN_MODULES: + found.append(f"from {node.module} import ...") + elif isinstance(node, ast.Attribute) and node.attr in FORBIDDEN_ATTRS: + found.append(f"call to .{node.attr}()") + elif isinstance(node, ast.Name) and node.id in FORBIDDEN_ATTRS: + found.append(f"reference to {node.id}") + return tuple(sorted(set(found))) + + +def control_no_measurement() -> None: + text = SOURCE.read_text(encoding="utf-8") + live = measurement_capabilities(ast.parse(text)) + if live: + fail("envcapture-no-measurement", + f"the capture tool can reach a clock or resource accounting: {', '.join(live)}") + return + + # The mutation is the proof. Without it this control is a claim. + mutated = text + ("\n\ndef _smuggled() -> float:\n" + " import time\n" + " return time.perf_counter()\n") + if not measurement_capabilities(ast.parse(mutated)): + fail("envcapture-no-measurement", + "the scanner did not catch a smuggled time.perf_counter(), so its silence on the " + "real module proves nothing") + return + + manifest = _live() + leaked = [k for k in manifest["identity"] # type: ignore[union-attr] + if any(w in k for w in ("elapsed", "duration", "nanos", "seconds", "rss", "usage"))] + if leaked: + fail("envcapture-no-measurement", + f"the manifest carries observation-shaped fields: {leaked}") + return + ok("envcapture-no-measurement", + f"no clock and no resource accounting reachable in {SOURCE.name}, proved by AST rather " + "than by text so its own disclaimer is not a finding; a smuggled perf_counter is caught; " + "and memory_bytes is installed RAM, not consumption") + + +# --- off Linux, and the frozen digests ------------------------------------- + + +WINDOWS_FIXTURE: dict[str, object] = { + "schema": ec.SCHEMA, + "measurement_free": True, + "identity": { + "environment_id": {"status": "observed", "value": "p022-win-01"}, + "host_fingerprint": {"status": "observed", "value": "sha256:" + "b" * 64}, + "os_build": {"status": "observed", + "value": "Windows 10 10.0.20348 SP0 Multiprocessor Free"}, + "kernel": {"status": "observed", "value": "10 10.0.20348"}, + "cpu_model": {"status": "observed", "value": "AMD EPYC 7763 64-Core Processor"}, + "logical_cpu_count": {"status": "observed", "value": 8}, + "memory_bytes": {"status": "observed", "value": 34359738368}, + "virtualization": {"status": "observed", "value": "microsoft"}, + "power_policy": {"status": "observed", "value": "High performance"}, + "python": {"status": "observed", "value": "CPython 3.11.9 (tags/v3.11.9) [MSC v.1938]"}, + "rustc": {"status": "observed", "value": "rustc 1.94.1; host: x86_64-pc-windows-msvc"}, + "dotnet": {"status": "observed", "value": "8.0.404"}, + }, + "provenance": { + "timestamp_utc": "2026-09-13T00:00:00+00:00", + "runner_name": None, + "workflow_run_id": None, + "job_id": None, + "ci": False, + }, + "note": "fixture", +} + + +# Mechanism names that exist on one platform only. A reason naming the other +# platform's mechanisms is a false statement about what was tried. +POSIX_ONLY = ("/sys/", "/proc/", "systemd-detect-virt", "scaling_governor", "cpufreq") +WINDOWS_ONLY = ("powercfg", "Win32_", "MachineGuid", "GlobalMemoryStatusEx", + "powershell", "pwsh") + + +def foreign_mechanisms(reason: str, *, on_windows: bool) -> tuple[str, ...]: + """Written once, used twice: on the live manifest and on a synthetic reason.""" + foreign = POSIX_ONLY if on_windows else WINDOWS_ONLY + return tuple(token for token in foreign if token in reason) + + +def control_reason_fits_platform() -> None: + """An 'unavailable' reason must describe THIS platform's mechanisms. + + The first Windows CI run of this tool reported `virtualization` unavailable + because "systemd-detect-virt absent ... and no DMI identity under /sys" — + true of every Windows machine ever built, and silent about the fact that + nothing Windows-specific had been tried at all. A stated reason that names + the wrong operating system is worse than no reason, because it reads as + though a probe ran. + """ + on_windows = os.name == "nt" + manifest = _live() + problems: list[str] = [] + for name, field in manifest["identity"].items(): # type: ignore[union-attr] + if field.get("status") != ec.UNAVAILABLE: + continue + found = foreign_mechanisms(str(field.get("reason", "")), on_windows=on_windows) + if found: + problems.append(f"{name} blames {', '.join(found)}") + if problems: + fail("envcapture-reason-fits-platform", + f"on {'Windows' if on_windows else 'POSIX'}, " + + "; ".join(problems)) + return + + # The scanner must actually catch the defect that prompted it, or its silence + # on the live manifest proves nothing. + regression = "systemd-detect-virt absent or unclear and no DMI identity under /sys" + if not foreign_mechanisms(regression, on_windows=True): + fail("envcapture-reason-fits-platform", + "the scanner does not catch the exact Windows reason that prompted it") + return + if foreign_mechanisms(regression, on_windows=False): + fail("envcapture-reason-fits-platform", + "the scanner calls a POSIX reason foreign on POSIX") + return + ok("envcapture-reason-fits-platform", + f"every unavailable reason on {'Windows' if on_windows else 'POSIX'} names a mechanism " + "that exists here, and the Windows virtualization reason that shipped in the first " + "version is still caught") + + +def control_windows_fixture() -> None: + problems = ec.validate(WINDOWS_FIXTURE) + if problems: + fail("envcapture-windows-fixture", + f"a well-formed Windows manifest was refused: {problems}") + return + other = copy.deepcopy(WINDOWS_FIXTURE) + other["identity"]["power_policy"] = ec.observed("Balanced") # type: ignore[index] + if ec.identity_drift(WINDOWS_FIXTURE, other) != ("power_policy",): + fail("envcapture-windows-fixture", "a changed Windows power policy was not drift") + return + ok("envcapture-windows-fixture", + "the schema and the drift rule hold on a non-Linux manifest. This fixture does not run " + "the Windows capture path; the CI selftest on windows-latest does, and its first run " + "returned the registry fingerprint, powercfg and GlobalMemoryStatusEx but no " + "virtualization, which is what added the CIM query. What stays unverified is capture on " + "a DEDICATED Windows host, since a hosted runner is not one") + + +def _git(*args: str) -> tuple[int, bytes]: + proc = subprocess.run(["git", "-C", str(ROOT), *args], capture_output=True) + return proc.returncode, proc.stdout + + +def _root_digest(root: str) -> str | None: + rc, out = _git("ls-tree", "-r", "--long", "-z", "HEAD", "--", root) + if rc != 0: + return None + entries = [] + for record in out.decode("utf-8").split("\0"): + if not record.strip(): + continue + meta, path = record.split("\t", 1) + _mode, _kind, sha, _size = meta.split() + if path.endswith(".py"): + entries.append((path, _git("cat-file", "blob", sha)[1])) + return implementation_digest(entries) if entries else None + + +def control_frozen_untouched() -> None: + """Adding this tool must not move a digest steps 4, 5 and 6 are bound to.""" + problems: list[str] = [] + freeze = json.loads(FREEZE.read_text(encoding="utf-8")) + prereg = json.loads(PREREG.read_text(encoding="utf-8")) + bindings = prereg["bindings"] + + live_harness = pb.harness_digest() + if live_harness != freeze["measurement_harness_digest"]: + problems.append(f"the live harness now hashes to {live_harness[:12]}, not the frozen one") + + policy = _root_digest(freeze["policy_source_root"]) + if policy != freeze["policy_implementation_digest"]: + problems.append(f"scripts/calibration/ now hashes to {policy and policy[:12]}") + scope = _root_digest(bindings["training_scope_root"]) + if scope != bindings["training_scope_implementation_digest"]: + problems.append(f"scripts/training/ now hashes to {scope and scope[:12]}") + + if str(SOURCE.relative_to(ROOT)).replace(os.sep, "/").startswith( + (freeze["policy_source_root"], bindings["training_scope_root"])): + problems.append("the capture tool was placed inside a frozen root") + + if problems: + fail("envcapture-frozen-untouched", "; ".join(problems)) + else: + ok("envcapture-frozen-untouched", + "the capture tool lives outside all three frozen source sets, so the harness digest " + "and the step-4 and step-6 digests are exactly what steps 4, 5 and 6 were accepted on") + + +def control_ci_provenance() -> None: + """A manifest taken on a hosted runner must say so rather than look host-taken.""" + saved = {k: os.environ.get(k) for k in ("CI", "RUNNER_NAME", "GITHUB_RUN_ID", "GITHUB_JOB")} + try: + os.environ.update({"CI": "true", "RUNNER_NAME": "GitHub Actions 3", + "GITHUB_RUN_ID": "34701945292", "GITHUB_JOB": "perf-instrument"}) + manifest = ec.capture("would-be-environment") + finally: + for key, value in saved.items(): + if value is None: + os.environ.pop(key, None) + else: + os.environ[key] = value + prov = manifest["provenance"] + missing = [k for k, want in (("ci", True), ("runner_name", "GitHub Actions 3"), + ("workflow_run_id", "34701945292"), + ("job_id", "perf-instrument")) + if prov.get(k) != want] # type: ignore[union-attr] + if missing: + fail("envcapture-ci-provenance", + f"a manifest captured on a hosted runner did not record {missing}") + return + ok("envcapture-ci-provenance", + "a manifest taken on a hosted runner records the runner, run and job and sets ci true, " + "so it cannot later be presented as taken on a dedicated measurement host") + + +def guard_failure(control: Callable[[], None]) -> str | None: + """Run a control; return the message a failure should carry, or None. + + Split from `guarded` so the probe below can exercise it WITHOUT printing a + `FAIL[` line. The first version reported through `fail()` and then deleted + the entry from the list — which left a literal `FAIL[envcapture-guard-fixture]` + in every green CI log, exactly the string this repository's mutation scorer + keys on. A green run must not print a failure. + """ + try: + control() + except Exception as exc: # the point is that nothing escapes + return (f"the control raised {type(exc).__name__}: {exc}. A control that crashes " + "before reporting is a traceback, not a finding") + return None + + +def guarded(name: str, control: Callable[[], None]) -> None: + """Report an escaping exception instead of dying of it. + + Recorded eight times in this PR now: a control that crashes before reporting + is a traceback, not a finding, and the run that dies on control one never + reaches control three. The mutation that exposed this instance promoted + `runner_name` into IDENTITY_FIELDS, which killed the fixture builder before + `envcapture-identity-split` — the control that owns exactly that defect — + could say a word. + """ + message = guard_failure(control) + if message is not None: + fail(name, message) + + +def control_guard_reports() -> None: + """The guard is the durable answer to a defect recorded eight times. Prove it. + + A scratchpad campaign that once watched a crash get reported is not a + regression catcher; restoring the bare call in `run()` has to fail here. + """ + def always_raises() -> None: + raise RuntimeError("a control that dies before reporting") + + try: + message = guard_failure(always_raises) + except Exception as exc: # nothing may escape, including from the guard + fail("envcapture-guard-reports", + f"guard_failure() let {type(exc).__name__} escape, so one crashing control still " + "kills every control after it") + return + if message is None: + fail("envcapture-guard-reports", "a raising control was reported as clean") + return + if "RuntimeError" not in message: + fail("envcapture-guard-reports", + f"the report does not name the exception type: {message!r}") + return + if guard_failure(lambda: None) is not None: + fail("envcapture-guard-reports", "a clean control was reported as a failure") + return + ok("envcapture-guard-reports", + "a control that raises is reported by name and the run continues, a clean one is not, " + "and this probe prints no FAIL line of its own on a green run") + + +def run() -> int: + guarded("envcapture-guard-reports", control_guard_reports) + guarded("envcapture-schema", control_schema) + guarded("envcapture-field-contract", control_field_contract) + guarded("envcapture-identity-split", control_identity_split) + guarded("envcapture-assigned-id", control_assigned_id) + guarded("envcapture-drift", control_drift) + guarded("envcapture-no-measurement", control_no_measurement) + guarded("envcapture-reason-fits-platform", control_reason_fits_platform) + guarded("envcapture-windows-fixture", control_windows_fixture) + guarded("envcapture-frozen-untouched", control_frozen_untouched) + guarded("envcapture-ci-provenance", control_ci_provenance) + print() + print(f"step 7 environment capture controls: {len(_PASSES)} passed, {len(_FAILURES)} failed") + return 1 if _FAILURES else 0 + + +if __name__ == "__main__": + sys.exit(run()) diff --git a/tests/test_training_prereg.py b/tests/test_training_prereg.py new file mode 100644 index 00000000..c9dad359 --- /dev/null +++ b/tests/test_training_prereg.py @@ -0,0 +1,601 @@ +#!/usr/bin/env python3 +"""#263-A calibration — step 6, the training preregistration and its scope combiner. + +Step 6 fixes the protocol of a training collection that has not happened. It +contains no clock, no observation, no fitted constant and no selected N. + + training-scope-purity the combiner is pure and holds no value + training-scope-admissible Q_p is READ OFF the frozen selector, not recomputed + training-scope-intersection smallest common rung, or NO_COMMON_N with no number + training-scope-refusals a missing rung or stratum stops rather than shrinks + training-prereg-shape the artifact is protocol, never a result + training-prereg-bindings all three digests equal the live ones + training-prereg-universe the declared universe is the instrument's own + training-no-incidental-measurement no workflow can reach a clock while step 7 is shut + training-scanner-catches-multiline the known multiline bypass stays caught, permanently + +`training-scope-admissible` is the load-bearing one. The margin `(1 + G)` must be +applied exactly once, inside the frozen `select_n`, so the control perturbs the +`limit` the frozen function reported and requires the combiner's answer to move. +A combiner that recomputed the margin itself would ignore that and pass. + +Failures print `FAIL[]: `; nothing stops at the first one. + +Run: python tests/test_training_prereg.py +""" + +from __future__ import annotations + +import ast +import json +import subprocess +import sys +from fractions import Fraction +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / "scripts")) +sys.path.insert(0, str(ROOT / "scripts" / "calibration")) +sys.path.insert(0, str(ROOT / "scripts" / "training")) +sys.path.insert(0, str(ROOT / "tests")) + +import perf_baseline as pb # noqa: E402 +import policy as pol # noqa: E402 +import scope as sc # noqa: E402 +from test_calibration_freeze import implementation_digest # noqa: E402 + +PREREG = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-training-preregistration.json" +FREEZE = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-policy-freeze.json" +CONSTANTS = ROOT / "docs" / "evidence" / "calibration" / "p022-263a-design-constants.json" +SCOPE_SOURCE = ROOT / "scripts" / "training" / "scope.py" +SCOPE_ROOT = "scripts/training/" +# A committed pre-step-6 report, used ONLY as a witness of which cells the frozen +# instrument emits. It is excluded from U as training data and is not read as one. +UNIVERSE_WITNESS = (ROOT / "docs" / "evidence" / "historical" + / "p022-263a-calibration-run-a.linux.json") + +_FAILURES: list[tuple[str, str]] = [] +_PASSES: list[str] = [] + + +def fail(check: str, detail: str) -> None: + _FAILURES.append((check, detail)) + print(f"FAIL[{check}]: {detail}") + + +def ok(check: str, detail: str = "") -> None: + _PASSES.append(check) + print(f"ok[{check}]: {detail}" if detail else f"ok[{check}]") + + +def _constants() -> pol.DesignConstants: + c = json.loads(CONSTANTS.read_text(encoding="utf-8"))["constants"] + return pol.DesignConstants.from_committed( + q=tuple(c["q"]), m=tuple(c["M"]), r_runs=c["R_runs"], + n_ladder=c["N_ladder"], g=tuple(c["G"])) + + +def _selection(widths: dict[int, int], constants: pol.DesignConstants) -> dict[str, object]: + """A real frozen-selector result: one cell of unit duration, envelope a_abs = width.""" + envelopes = {n: pol.Envelope(n=n, a_abs=Fraction(w), r_rel=Fraction(0)) + for n, w in widths.items()} + reference = {n: [Fraction(1)] for n in widths} + return pol.select_n(envelopes, reference, constants) + + +def control_purity() -> None: + tree = ast.parse(SCOPE_SOURCE.read_text(encoding="utf-8")) + imported: set[str] = set() + problems: list[str] = [] + for node in ast.walk(tree): + if isinstance(node, ast.Import): + imported.update(a.name for a in node.names) + elif isinstance(node, ast.ImportFrom) and node.module: + imported.add(node.module) + elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + for default in list(node.args.defaults) + [d for d in node.args.kw_defaults if d]: + if isinstance(default, ast.Constant) and isinstance(default.value, (int, float)): + problems.append(f"{node.name} carries the numeric default {default.value!r}") + elif isinstance(node, ast.Assign): + for target in node.targets: + mutable = isinstance(node.value, (ast.List, ast.Dict, ast.Set)) + if isinstance(target, ast.Name) and mutable: + problems.append(f"module-level mutable {target.id}") + allowed = {"__future__", "collections.abc", "fractions", "policy"} + if imported - allowed: + problems.append(f"imports outside the permitted set: {sorted(imported - allowed)}") + if problems: + fail("training-scope-purity", "; ".join(problems)) + else: + ok("training-scope-purity", + f"imports are {sorted(imported)} and nothing else; no numeric default and no " + "module-level mutable state; no clock, no filesystem, no randomness") + + +def control_admissible(c: pol.DesignConstants) -> None: + problems: list[str] = [] + sel = _selection({5: 100, 15: 10, 45: 10}, c) + q = sc.admissible_rungs(sel, c, stratum="t") + if q != (15, 45): + problems.append(f"Q is {q}, expected (15, 45) for widths 100/10/10 at G=1/10") + if sel["selected_n"] not in q: + problems.append("the stratum's own frozen pick is not in its own admissible set") + + # The margin must be applied ONCE, inside the frozen selector. Perturb the limit + # the frozen function reported: a combiner that recomputed (1 + G) itself would + # ignore this and answer the same. + tightened = dict(sel) + tightened["limit"] = pol.as_pair(Fraction(10)) # exactly the best width + q_tight = sc.admissible_rungs(tightened, c, stratum="t") + if q_tight != (15, 45): + problems.append(f"tightening the limit to the best width gave {q_tight}") + loosened = dict(sel) + loosened["limit"] = pol.as_pair(Fraction(1000)) + if sc.admissible_rungs(loosened, c, stratum="t") != (5, 15, 45): + problems.append("loosening the reported limit did not widen the admissible set, so " + "the combiner is not reading the frozen limit at all") + + zero_g = pol.DesignConstants.from_committed(q=(19, 20), m=(2, 1), r_runs=5, + n_ladder=[5, 15, 45], g=(0, 1)) + tight = _selection({5: 100, 15: 10, 45: 20}, zero_g) + if sc.admissible_rungs(tight, zero_g, stratum="t") != (15,): + problems.append("at G = 0 the admissible set is not exactly the argmin") + + if problems: + fail("training-scope-admissible", "; ".join(problems)) + else: + ok("training-scope-admissible", + "Q is read off the frozen selector's own widths and limit: perturbing that " + "limit moves the answer, G = 0 gives exactly the argmin, and each stratum's " + "own frozen pick is always inside its own set") + + +def control_intersection(c: pol.DesignConstants) -> None: + problems: list[str] = [] + lin = _selection({5: 100, 15: 10, 45: 10}, c) # Q = (15, 45) + win = _selection({5: 100, 15: 50, 45: 10}, c) # Q = (45,) + r = sc.combine({"linux": lin, "windows": win}, c, strata=("linux", "windows")) + if r["outcome"] != sc.OUTCOME_SELECTED or r.get("selected_n") != 45: + problems.append(f"expected SELECTED n=45, got {r['outcome']} {r.get('selected_n')}") + if r["q_common"] != (45,): + problems.append(f"q_common is {r['q_common']}") + + # Disjoint: max of the per-stratum picks would name a rung admissible on neither. + a = _selection({5: 10, 15: 100, 45: 60}, c) # Q = (5,) + b = _selection({5: 60, 15: 100, 45: 10}, c) # Q = (45,) + r2 = sc.combine({"linux": a, "windows": b}, c, strata=("linux", "windows")) + if r2["outcome"] != sc.OUTCOME_NO_COMMON_N: + problems.append(f"disjoint strata gave {r2['outcome']}") + if "selected_n" in r2: + problems.append("NO_COMMON_N carries a selected_n key, so a caller reading it " + "blindly proceeds on a number the rule did not select") + worst = max(int(str(a["selected_n"])), int(str(b["selected_n"]))) + qa, qb = sc.admissible_rungs(a, c, stratum="a"), sc.admissible_rungs(b, c, stratum="b") + if worst in qa and worst in qb: + problems.append("the max-of-picks counterexample no longer demonstrates anything") + + # Order: the smallest common rung, never the stratum's own pick. + both = _selection({5: 10, 15: 10, 45: 10}, c) # Q = (5, 15, 45) + r3 = sc.combine({"linux": both, "windows": both}, c, strata=("linux", "windows")) + if r3.get("selected_n") != 5: + problems.append("with every rung common the smallest was not chosen: " + f"{r3.get('selected_n')}") + + if problems: + fail("training-scope-intersection", "; ".join(problems)) + else: + ok("training-scope-intersection", + "the smallest rung admissible on both strata wins; disjoint sets stop at " + f"NO_COMMON_N with no selected_n key, where max-of-picks would have named " + f"n={worst}, which is admissible on neither") + + +def control_refusals(c: pol.DesignConstants) -> None: + good = _selection({5: 100, 15: 10, 45: 10}, c) + missing = dict(good) + missing["widths"] = {5: pol.as_pair(Fraction(100)), 15: pol.as_pair(Fraction(10))} + cases = [ + ("one stratum only", lambda: sc.combine({"linux": good}, c, strata=("linux",))), + ("a stratum named twice", + lambda: sc.combine({"linux": good}, c, strata=("linux", "linux"))), + ("selections and strata disagree", + lambda: sc.combine({"linux": good}, c, strata=("linux", "windows"))), + ("a rung missing from a stratum", lambda: sc.admissible_rungs(missing, c, stratum="t")), + ("no widths mapping", lambda: sc.admissible_rungs( + {"limit": pol.as_pair(Fraction(1))}, c, stratum="t")), + ("a float width", lambda: sc.admissible_rungs( + {"widths": {5: 1.0, 15: 1.0, 45: 1.0}, "limit": pol.as_pair(Fraction(1))}, + c, stratum="t")), + ("a width that is not a reduced pair", lambda: sc.admissible_rungs( + {"widths": {5: (2, 4), 15: (1, 1), 45: (1, 1)}, "limit": pol.as_pair(Fraction(1))}, + c, stratum="t")), + ] + problems = [] + for name, call in cases: + verdict = _refusal(call) + if verdict: + problems.append(f"{name}: {verdict}") + if problems: + fail("training-scope-refusals", "; ".join(problems)) + else: + ok("training-scope-refusals", + f"all {len(cases)} malformed scopes refused BY NAME, including a float width " + "and a rung that was never measured") + + +def _refusal(call: object) -> str: + """Empty when the call refused by name. Anything else is the defect. + + An earlier draft caught bare `Exception` and scored that as a refusal, so a + `KeyError` from a guard that had been deleted read exactly like the guard + working. That is the defect this PR has now recorded seven times: a control + that cannot tell a traceback from a finding. A crash is reported here, never + counted as a refusal. + """ + try: + call() # type: ignore[operator] + except (sc.ScopeRefused, pol.PolicyRefused): + return "" + except Exception as exc: # reported, never swallowed + return f"crashed with {type(exc).__name__} instead of refusing by name: {exc}" + return "accepted rather than refused" + + +def control_prereg_shape(art: dict[str, object]) -> None: + permitted = {"artifact", "anchor_commit", "bindings", "design_constants", "stratification", + "universe", "collection_protocol", "order", "run_identity_required_fields", + "identity_drift_rule", "abort_semantics", "exactly_one_collection", + "future_procedure", "holdout", "forbidden_in_step_6", "ratified_by", + "step_7_collection", "admissibility_of_observations"} + problems: list[str] = [] + if set(art) != permitted: + problems.append(f"keys are {sorted(set(art) ^ permitted)} away from the permitted set") + + forbidden_keys = {"A_abs", "R_rel", "a_abs", "r_rel", "selected_n", "selected_N", + "envelope", "envelopes", "widths", "measurements", "median_ns", + "elapsed_ns", "fitted"} + + def keys(node: object) -> list[str]: + if isinstance(node, dict): + return list(node) + [k for v in node.values() for k in keys(v)] + if isinstance(node, list): + return [k for item in node for k in keys(item)] + return [] + + def floats(node: object) -> list[object]: + if isinstance(node, dict): + return [f for v in node.values() for f in floats(v)] + if isinstance(node, list): + return [f for item in node for f in floats(item)] + return [node] if isinstance(node, float) else [] + + present = sorted(set(keys(art)) & forbidden_keys) + if present: + problems.append(f"keys naming a fitted or measured quantity: {present}; step 6 " + "preregisters a protocol and produces no result of it") + if floats(art): + problems.append(f"floating-point values: {floats(art)}") + if art.get("ratified_by") != "owner": + problems.append("ratified_by is not 'owner'") + if art.get("step_7_collection") != STEP_7_CLOSED: + problems.append(f"step_7_collection is {art.get('step_7_collection')!r}; a step 6 " + f"artifact records exactly {STEP_7_CLOSED!r} and cannot carry its " + "own authorisation to start measuring") + if problems: + fail("training-prereg-shape", "; ".join(problems)) + else: + ok("training-prereg-shape", + f"{len(permitted)} permitted top-level keys, no key naming a fitted or measured " + "quantity anywhere, and no float") + + +def control_prereg_bindings(art: dict[str, object]) -> None: + problems: list[str] = [] + b = art.get("bindings") + if not isinstance(b, dict): + fail("training-prereg-bindings", "bindings is not an object") + return + freeze = json.loads(FREEZE.read_text(encoding="utf-8")) + constants = json.loads(CONSTANTS.read_text(encoding="utf-8")) + + if b.get("policy_implementation_digest") != freeze.get("policy_implementation_digest"): + problems.append("the bound policy digest is not the one step 4 froze") + live = pb.harness_digest() + if b.get("measurement_harness_digest") != live: + problems.append(f"the bound harness digest is not the live {live[:12]}") + if art.get("design_constants") != constants.get("constants"): + problems.append("the echoed design constants are not the step 5 artifact's") + + rc, out = _git("ls-tree", "-r", "--long", "-z", "HEAD", "--", SCOPE_ROOT) + if rc != 0: + problems.append("git could not list the training scope root at HEAD") + else: + entries = [] + for record in out.decode("utf-8").split("\0"): + if not record.strip(): + continue + meta, path = record.split("\t", 1) + _mode, _kind, sha, _size = meta.split() + if path.endswith(".py"): + entries.append((path, _git("cat-file", "blob", sha)[1])) + if not entries: + problems.append(f"{SCOPE_ROOT} contains no committed *.py at HEAD") + else: + # The step 4 framing, imported rather than restated: a second copy of + # the byte layout would only ever prove the two copies agree. + recomputed = implementation_digest(entries) + if b.get("training_scope_implementation_digest") != recomputed: + problems.append(f"the bound scope digest is not the {recomputed[:12]} that " + f"{len(entries)} committed file(s) hash to under that " + "framing") + if problems: + fail("training-prereg-bindings", "; ".join(problems)) + else: + ok("training-prereg-bindings", + "all three digests bind: policy to what step 4 froze, harness to the live " + "instrument, and the scope combiner to its own committed bytes") + + +def _git(*args: str) -> tuple[int, bytes]: + proc = subprocess.run(["git", "-C", str(ROOT), *args], capture_output=True) + return proc.returncode, proc.stdout + + +def control_prereg_universe(art: dict[str, object]) -> None: + """The declared universe must be the instrument's own, not a number I typed.""" + u = art.get("universe") + if not isinstance(u, dict): + fail("training-prereg-universe", "universe is not an object") + return + problems: list[str] = [] + manifest = pb.load_manifest() + workloads = manifest[0] if isinstance(manifest, tuple) else manifest + calibration = sorted(w.id for w in workloads if not w.decisive) + if sorted(u.get("calibration_workloads", [])) != calibration: + problems.append(f"declared workloads are not the manifest's {calibration}") + if list(u.get("rungs", [])) != [r.id for r in pb.RUNGS]: + problems.append(f"declared rungs are not the instrument's {[r.id for r in pb.RUNGS]}") + if tuple(u.get("regimes", [])) != pb.D7_REGIMES: + problems.append(f"declared regimes are not {list(pb.D7_REGIMES)}") + + witness = json.loads(UNIVERSE_WITNESS.read_text(encoding="utf-8")) + cells = witness.get("cells") + if not isinstance(cells, list): + problems.append("the universe witness carries no cells") + else: + if u.get("expected_cells_per_stratum") != len(cells): + problems.append(f"declared {u.get('expected_cells_per_stratum')} cells per stratum " + f"but the instrument emits {len(cells)}") + seen_workloads = sorted({str(c["workload"]) for c in cells}) + if seen_workloads != calibration: + problems.append(f"the witness covers {seen_workloads}, not the declared universe") + identity = sorted({tuple(sorted(set(c) & {"rung", "engine", "workload", "regime"})) + for c in cells}) + if identity != [("engine", "regime", "rung", "workload")]: + problems.append("the emitted cells do not carry the four-part identity") + if problems: + fail("training-prereg-universe", "; ".join(problems)) + else: + ok("training-prereg-universe", + f"{u.get('expected_cells_per_stratum')} cells per stratum, over the manifest's " + f"{len(calibration)} calibration workloads, the instrument's {len(pb.RUNGS)} rungs " + "and both regimes, each carrying the frozen four-part identity") + + +STEP_7_CLOSED = "NOT AUTHORISED" + +WORKFLOWS = ROOT / ".github" / "workflows" +# Each guarded entrypoint, and the file that must still define its flag. Without the +# second half a rename would make this control pass by finding nothing, which is the +# proxy-instead-of-the-thing failure it exists to avoid. +MEASUREMENT_ENTRYPOINTS = ( + ("perf_baseline.py", "--calibrate", ROOT / "scripts" / "perf_baseline.py"), + ("runner.py", "--measure", ROOT / "scripts" / "round7" / "runner.py"), +) + + +def _shell_lines(text: str) -> list[str]: + """Workflow lines that could execute. A comment cannot, so it is not an invocation.""" + return [line for line in text.splitlines() if not line.lstrip().startswith("#")] + + +# The scan looks for the FLAG ALONE, never for the command name beside it. An +# earlier version required both on one physical line, and the repository's own +# Round 7 invocation is written across four: +# +# python scripts/round7/runner.py \ +# --candidate "..." \ +# --plan --build-dir "..." \ +# --out "..." +# +# Changing that one word to --measure turned a plan-only step into a real +# measurement while the control stayed green, because the line naming the script +# had no flag and the line with the flag named no script. Driven, not argued: the +# mutation came back MISSED. A capability token is forbidden outright while step 7 +# is shut, wherever it appears and whatever sits next to it, so line breaks, +# variables and quoting cannot get between the guard and the thing it guards. + + +def forbidden_measurement_capabilities(text: str) -> tuple[str, ...]: + """Every forbidden capability token in EXECUTABLE workflow text. + + Written once and used twice: the live control runs it over each workflow file + on disk, and `training-scanner-catches-multiline` runs it over mutated text in + memory. A second copy for the tests would only prove the two copies agree, + which is the defect this PR has spent fourteen rounds removing. + """ + return tuple(f"{flag} on: {line.strip()}" + for line in _shell_lines(text) + for _name, flag, _source in MEASUREMENT_ENTRYPOINTS + if flag in line) + + +def control_no_incidental_measurement(art: dict[str, object]) -> None: + """While step 7 is shut, no workflow may hold a path to a measurement entrypoint. + + Step 6 preregisters a protocol and takes no observation. That claim was false on + the commit that first made it: the legacy calibration pair still ran in CI, timing + forty cells per platform on every push and uploading them. A preregistration that + fixes "exactly one collection" while CI gathers numbers on a timer has an epistemic + side channel whatever anyone means to do with the output. This is the mechanical + version of the rule, so the next person to add a convenient diagnostic finds the + suite red rather than a reviewer's memory. + """ + state = art.get("step_7_collection") + if state != STEP_7_CLOSED: + # Fail-closed, and with no authorised branch at all. The first version of + # this read `!= "NOT AUTHORISED"` and then RETURNED OK, so every state that + # was not the exact refusal -- a typo, a missing key after some later schema + # change, null, an American spelling, or the word AUTHORISED itself -- + # silently meant permission to start a clock. That is fail-closed with the + # polarity reversed. Step 6 is a preregistration and cannot open step 7: + # when step 7 is really authorised, a separate reviewed artifact and a + # separate owner decision change the orchestration, rather than this + # document mutating into a permission bit its own producer can flip. + fail("training-no-incidental-measurement", + f"unknown or unauthorised authority transition: {state!r}; step 6 cannot " + f"open step 7, and the only state this control accepts is {STEP_7_CLOSED!r}") + return + + problems: list[str] = [] + for _name, flag, source in MEASUREMENT_ENTRYPOINTS: + if not source.exists(): + problems.append(f"{source.name} is gone, so guarding {flag} proves nothing") + elif f'"{flag}"' not in source.read_text(encoding="utf-8"): + problems.append(f"{source.name} no longer defines {flag}; this guard would pass " + "by finding a flag that has been renamed") + + if not WORKFLOWS.is_dir(): + problems.append(f"{WORKFLOWS} is not a directory, so no workflow could be read") + else: + scanned = sorted(WORKFLOWS.glob("*.yml")) + sorted(WORKFLOWS.glob("*.yaml")) + if not scanned: + problems.append("no workflow files were found, so this scanned nothing") + for workflow in scanned: + for hit in forbidden_measurement_capabilities(workflow.read_text(encoding="utf-8")): + problems.append(f"{workflow.name} contains a forbidden measurement capability, " + f"{hit}") + if problems: + fail("training-no-incidental-measurement", "; ".join(problems)) + else: + ok("training-no-incidental-measurement", + f"step 7 is shut and no executable line of any workflow carries " + f"{' or '.join(f for _, f, _ in MEASUREMENT_ENTRYPOINTS)}, wherever it appears and " + "whatever sits beside it; both flags still exist, so the guard is not passing on a " + "rename") + + +# A multiline invocation that has never existed in this repository since the timed +# pair was removed, kept as text so the `--calibrate` half of the bypass is guarded +# too. It is never written to disk and nothing here runs it. +CALIBRATE_ACROSS_LINES = ( + " - name: never\n" + " run: |\n" + " python scripts/perf_baseline.py \\\n" + " --calibrate --repeat 5 \\\n" + ' --out "$RUNNER_TEMP/cal-1.json"\n' +) + + +def _round7_invocation(text: str) -> str: + """The Round 7 runner call as ci.yml writes it: the line naming the script plus + every continuation it carries. Returns "" when there is none.""" + lines = text.splitlines() + for index, line in enumerate(lines): + if "round7/runner.py" in line and not line.lstrip().startswith("#"): + block = [line] + while block[-1].rstrip().endswith("\\") and index + len(block) < len(lines): + block.append(lines[index + len(block)]) + return "\n".join(block) + return "" + + +def control_scanner_catches_multiline() -> None: + """The bypass that defeated the earlier scanner, kept as a standing catcher. + + The scanner once required the command name and the flag on the same physical + line. The Round 7 step spans four lines with `--plan` alone on a continuation, + so turning that one word into `--measure` made a plan-only step a real + measurement while the control stayed green. That was found by a manual + campaign, and a campaign is a memory rather than a property: restore the old + conjunction and the live workflow still says `--plan`, so CI goes green and + nothing notices. + + The mutant is therefore derived from the REAL Round 7 block rather than a + synthetic copy that could drift away from it, mutated in memory, never written + to disk. Nothing here starts a clock. + + Scoped to that block on purpose. An earlier draft searched the whole file for + any `--plan`, and ci.yml has a second one that is a stale-plan.json path in an + unrelated stage 2 step. The control passed by mutating that instead, and its + success line claimed both belonged to Round 7. Found by its own mutation + reporting MISSED. + """ + problems: list[str] = [] + ci = WORKFLOWS / "ci.yml" + if not ci.exists(): + fail("training-scanner-catches-multiline", "ci.yml is gone, so this proves nothing") + return + text = ci.read_text(encoding="utf-8") + + if forbidden_measurement_capabilities(text): + problems.append("the live ci.yml is already reported as forbidden: " + f"{forbidden_measurement_capabilities(text)}") + + block = _round7_invocation(text) + carriers = [line for line in _shell_lines(block) + if "--plan" in line and "runner.py" not in line] + if not block: + problems.append("no Round 7 runner invocation was found in ci.yml, so the mutation " + "below would test nothing") + elif not carriers: + problems.append(f"the Round 7 invocation carries no continuation line with --plan away " + f"from the script name, so the multiline mutation is a no-op and this " + f"control would pass without testing anything: {block!r}") + else: + if forbidden_measurement_capabilities(block): + problems.append("the real plan-only Round 7 block is itself reported as forbidden") + if not any("--measure" in hit for hit in + forbidden_measurement_capabilities(block.replace("--plan", "--measure"))): + problems.append("--plan turned into --measure on its own continuation line of the " + "REAL Round 7 block is NOT caught; that is the exact bypass an " + "earlier scanner missed, and the scanner has regressed to matching " + "a command name") + + if not any("--calibrate" in hit + for hit in forbidden_measurement_capabilities(CALIBRATE_ACROSS_LINES)): + problems.append("a multiline perf_baseline.py with --calibrate on the next line is NOT " + "caught") + + if problems: + fail("training-scanner-catches-multiline", "; ".join(problems)) + else: + ok("training-scanner-catches-multiline", + f"the live ci.yml is clean; its Round 7 invocation spans " + f"{len(block.splitlines())} lines with --plan on {len(carriers)} continuation line(s) " + "away from the script name, and turning that word into --measure is caught, as is " + "--calibrate split across lines. Nothing written to disk, no clock run") + + +def run() -> int: + constants = _constants() + control_purity() + control_admissible(constants) + control_intersection(constants) + control_refusals(constants) + if not PREREG.exists(): + fail("training-prereg-shape", f"{PREREG.name} does not exist") + else: + art = json.loads(PREREG.read_text(encoding="utf-8")) + control_prereg_shape(art) + control_prereg_bindings(art) + control_prereg_universe(art) + control_no_incidental_measurement(art) + control_scanner_catches_multiline() + print() + print(f"training preregistration controls: {len(_PASSES)} passed, {len(_FAILURES)} failed") + return 1 if _FAILURES else 0 + + +if __name__ == "__main__": + sys.exit(run())