+
Stable documentation
{% endblock %}
diff --git a/docs/release-checklist.md b/docs/release-checklist.md
index fa01131..6213883 100644
--- a/docs/release-checklist.md
+++ b/docs/release-checklist.md
@@ -4,7 +4,26 @@ This is the release gate and publication record for miniVERL. A checked item
names an invariant exercised on the stated source. Publication begins only
after the exact release commit and its remote checks are green.
-## v0.10.2 development
+## v0.11.0 development
+
+- [x] Advance the canonical development line to `0.11.0.dev0` while stable
+ release and documentation remain at immutable `v0.10.1`.
+- [x] Preregister the RTX 4080 Rollout Runtime v2 workload before measuring
+ the pre-v0.11 `hf_reference` baseline.
+- [ ] Freeze the `hf_reference` result before implementing `hf_cached`.
+- [ ] Add typed policy identity, lifecycle and strict synchronization contracts.
+- [ ] Qualify `hf_cached` at 64/256/512 response bounds and require at least 2x
+ speedup at 256 and 512 without exceeding 14.5 GiB peak reserved VRAM.
+- [ ] Add transactional `samples_per_prompt > 1` and exact no-skip/no-duplicate
+ resume semantics without changing the published `n=1` profiles.
+- [ ] Add the new deterministic task-reward plus distillation-advantage profile;
+ keep direct GKD and existing PG-k1 identities unchanged.
+- [ ] Measure SGLang and vLLM on the same WSL2 RTX 4080 workload and support at
+ most one external engine after policy-sync, cache and teardown gates pass.
+- [ ] Run exact-candidate-wheel full qualification, dry-run and publication
+ only after every v0.11 acceptance gate passes.
+
+## v0.10.2 development (superseded by v0.11 scope)
- [ ] Define and review the next focused release scope before changing product
behavior or scientific evidence.
diff --git a/mkdocs.yml b/mkdocs.yml
index 7cbfbcc..6b9f7b6 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -71,6 +71,9 @@ nav:
- Demo recording script: verl-bridge-demo.md
- Legacy environment/PPO bridge: legacy-verl-bridge.md
- Community benchmarks: community-benchmarks.md
+ - Rollout Runtime v2:
+ - Competitive landscape: competitive-landscape.md
+ - Benchmark method: benchmarks/rollout-runtime-v2-method.md
- Maintainer:
- Architecture: maintainer-architecture.md
- Upstream support policy: upstream-support-policy.md
diff --git a/release-state.yaml b/release-state.yaml
index 67a1f6a..9b54407 100644
--- a/release-state.yaml
+++ b/release-state.yaml
@@ -26,4 +26,4 @@ stable:
released_at: "2026-08-16"
development:
- version: "0.10.2.dev0"
+ version: "0.11.0.dev0"
diff --git a/scripts/benchmark_rollout_runtime.py b/scripts/benchmark_rollout_runtime.py
new file mode 100644
index 0000000..ba5d630
--- /dev/null
+++ b/scripts/benchmark_rollout_runtime.py
@@ -0,0 +1,495 @@
+#!/usr/bin/env python3
+"""Measure the preregistered pre-v0.11 Hugging Face rollout baseline.
+
+The baseline intentionally exercises the public ``generate_batch`` contract
+that existed before Rollout Runtime v2. It does not import or anticipate the
+new backend implementation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import hashlib
+import importlib.metadata
+import json
+import platform
+import statistics
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+import jsonschema
+import torch
+import yaml
+
+from miniverl import __version__
+from miniverl.config.models import StudentModelConfig
+from miniverl.models.hf import HFBackend
+from miniverl.models.tokenizers import HFTokenizerAdapter
+from miniverl.utils.runs import canonical_json, write_json
+
+ROOT = Path(__file__).resolve().parents[1]
+PREREGISTRATION = ROOT / "benchmarks/preregistration/rollout-runtime-v2.yaml"
+SCHEMA = ROOT / "benchmarks/schema/rollout-runtime-v2.schema.json"
+DEFAULT_OUTPUT = ROOT / "benchmarks/results/rollout-runtime-v2-hf-reference.json"
+FROZEN_CALCULATOR = ROOT / "benchmarks/results/gpu-calc-hard-equal-update-v2.json"
+FROZEN_CALCULATOR_SHA256 = "53fc1d4d5b7adee09618d77ad62d4086ba56b78569832d6fc7c3bcd5c2695bbc"
+
+
+def _sha256(path: Path) -> str:
+ digest = hashlib.sha256()
+ with path.open("rb") as handle:
+ for block in iter(lambda: handle.read(1024 * 1024), b""):
+ digest.update(block)
+ return digest.hexdigest()
+
+
+def _git(*args: str) -> str:
+ return subprocess.check_output(["git", *args], cwd=ROOT, text=True).strip()
+
+
+def _phase(
+ status: str,
+ *,
+ values: list[float] | None = None,
+ note: str = "",
+) -> dict[str, Any]:
+ payload: dict[str, Any] = {"status": status}
+ if values:
+ payload["median_seconds"] = float(statistics.median(values))
+ payload["minimum_seconds"] = float(min(values))
+ if note:
+ payload["note"] = note
+ return payload
+
+
+def _package_version(name: str) -> str | None:
+ try:
+ return importlib.metadata.version(name)
+ except importlib.metadata.PackageNotFoundError:
+ return None
+
+
+def _environment() -> dict[str, Any]:
+ return {
+ "platform": platform.platform(),
+ "python": platform.python_version(),
+ "gpu": torch.cuda.get_device_name(0),
+ "gpu_total_memory_bytes": int(torch.cuda.get_device_properties(0).total_memory),
+ "cuda_runtime": torch.version.cuda,
+ "packages": {
+ name: _package_version(name)
+ for name in ("torch", "transformers", "peft", "bitsandbytes", "accelerate")
+ },
+ }
+
+
+def _rss_bytes() -> int | None:
+ try:
+ import resource
+
+ return int(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * 1024)
+ except (ImportError, OSError):
+ return None
+
+
+def _fixed_prompt(tokenizer: Any, *, length: int, index: int) -> list[int]:
+ prefix = list(tokenizer.encode(f"System benchmark prompt {index}. Continue with text."))
+ filler = list(tokenizer.encode(" benchmark"))
+ if not filler:
+ raise RuntimeError("tokenizer produced no filler tokens")
+ while len(prefix) < length:
+ prefix.extend(filler)
+ prompt = prefix[:length]
+ if tokenizer.eos_token_id is not None and prompt[-1] == tokenizer.eos_token_id:
+ replacement = next(token for token in filler if token != tokenizer.eos_token_id)
+ prompt[-1] = replacement
+ if len(prompt) != length:
+ raise AssertionError("fixed prompt construction changed the requested token length")
+ return prompt
+
+
+def _digest_outputs(outputs: list[Any]) -> tuple[str, str]:
+ ids = [output.token_ids for output in outputs]
+ probabilities = [output.logprobs for output in outputs]
+ return (
+ hashlib.sha256(canonical_json(ids).encode("utf-8")).hexdigest(),
+ hashlib.sha256(canonical_json(probabilities).encode("utf-8")).hexdigest(),
+ )
+
+
+def _generate_once(
+ backend: HFBackend,
+ *,
+ prompts: list[list[int]],
+ seeds: list[int],
+ response_bound: int,
+ sampling: dict[str, Any],
+ physical_batch_size: int,
+) -> tuple[list[Any], int]:
+ outputs: list[Any] = []
+ physical_batches = 0
+ for start in range(0, len(prompts), physical_batch_size):
+ end = start + physical_batch_size
+ outputs.extend(
+ backend.generate_batch(
+ prompts[start:end],
+ max_new_tokens=response_bound,
+ temperature=float(sampling["temperature"]),
+ top_p=float(sampling["top_p"]),
+ top_k=int(sampling["top_k"]),
+ seeds=seeds[start:end],
+ record_logprobs=True,
+ )
+ )
+ physical_batches += 1
+ return outputs, physical_batches
+
+
+def _failed_cell(
+ *,
+ cell_id: str,
+ prompt_length: int,
+ response_bound: int,
+ samples_per_prompt: int,
+ sampling: str,
+ status: str,
+ error: str,
+) -> dict[str, Any]:
+ unavailable = _phase("failed", note=error)
+ return {
+ "cell_id": cell_id,
+ "prompt_length": prompt_length,
+ "response_bound": response_bound,
+ "samples_per_prompt": samples_per_prompt,
+ "sampling": sampling,
+ "status": status,
+ "counts": {
+ "logical_prompts": 0,
+ "generated_trajectories": 0,
+ "prompt_tokens": 0,
+ "generated_tokens": 0,
+ "physical_batches": 0,
+ },
+ "phases": {
+ name: dict(unavailable)
+ for name in (
+ "cold_start",
+ "prefill",
+ "decode",
+ "rollout_total",
+ "policy_sync",
+ "teacher_scoring",
+ "actor_update",
+ "full_cycle",
+ "teardown",
+ )
+ },
+ "rates": {
+ "time_to_first_token_seconds": None,
+ "prompt_tokens_per_second": None,
+ "output_tokens_per_second": None,
+ },
+ "memory": {
+ "peak_allocated_bytes": int(torch.cuda.max_memory_allocated()),
+ "peak_reserved_bytes": int(torch.cuda.max_memory_reserved()),
+ "process_rss_bytes": _rss_bytes(),
+ "teardown_residual_allocated_bytes": None,
+ },
+ "output_token_ids_sha256": None,
+ "sampled_logprobs_sha256": None,
+ "oom_downshifts": 0,
+ "error": error,
+ }
+
+
+def _cell(
+ backend: HFBackend,
+ *,
+ tokenizer: Any,
+ prompt_length: int,
+ response_bound: int,
+ samples_per_prompt: int,
+ sampling: dict[str, Any],
+ workload: dict[str, Any],
+ cold_start_seconds: float,
+) -> dict[str, Any]:
+ sampling_name = str(sampling["name"])
+ cell_id = f"p{prompt_length}-r{response_bound}-n{samples_per_prompt}-{sampling_name}"
+ logical_prompts = int(workload["logical_prompts"])
+ run_seed = int(workload["run_seed"])
+ base_prompts = [
+ _fixed_prompt(tokenizer, length=prompt_length, index=index)
+ for index in range(logical_prompts)
+ ]
+ prompts: list[list[int]] = []
+ seeds: list[int] = []
+ for prompt in base_prompts:
+ prompt_digest = hashlib.sha256(canonical_json(prompt).encode("utf-8")).hexdigest()
+ for sample_index in range(samples_per_prompt):
+ prompts.append(prompt)
+ seed_payload = f"rollout-runtime-v2-seed-v1:{run_seed}:{prompt_digest}:0:{sample_index}"
+ seeds.append(int(hashlib.sha256(seed_payload.encode("ascii")).hexdigest()[:16], 16))
+
+ physical_batch_size = min(4, len(prompts))
+ try:
+ for _ in range(int(workload["warmup_repetitions"])):
+ _generate_once(
+ backend,
+ prompts=prompts,
+ seeds=seeds,
+ response_bound=response_bound,
+ sampling=sampling,
+ physical_batch_size=physical_batch_size,
+ )
+ torch.cuda.synchronize()
+ torch.cuda.reset_peak_memory_stats()
+ measured_seconds: list[float] = []
+ output_digests: list[tuple[str, str]] = []
+ final_outputs: list[Any] = []
+ physical_batches = 0
+ for _ in range(int(workload["measured_repetitions"])):
+ started = time.perf_counter()
+ final_outputs, physical_batches = _generate_once(
+ backend,
+ prompts=prompts,
+ seeds=seeds,
+ response_bound=response_bound,
+ sampling=sampling,
+ physical_batch_size=physical_batch_size,
+ )
+ torch.cuda.synchronize()
+ measured_seconds.append(time.perf_counter() - started)
+ output_digests.append(_digest_outputs(final_outputs))
+ if len(set(output_digests)) != 1:
+ raise RuntimeError("seeded reference output changed across measured repetitions")
+ generated_tokens = sum(len(output.token_ids) for output in final_outputs)
+ prompt_tokens = sum(len(prompt) for prompt in prompts)
+ median_seconds = float(statistics.median(measured_seconds))
+ output_ids_digest, logprobs_digest = output_digests[0]
+ return {
+ "cell_id": cell_id,
+ "prompt_length": prompt_length,
+ "response_bound": response_bound,
+ "samples_per_prompt": samples_per_prompt,
+ "sampling": sampling_name,
+ "status": "completed",
+ "counts": {
+ "logical_prompts": logical_prompts,
+ "generated_trajectories": len(final_outputs),
+ "prompt_tokens": prompt_tokens,
+ "generated_tokens": generated_tokens,
+ "physical_batches": physical_batches,
+ },
+ "phases": {
+ "cold_start": _phase(
+ "measured",
+ values=[cold_start_seconds],
+ note="shared actor/tokenizer load measurement repeated on each cell",
+ ),
+ "prefill": _phase(
+ "not_measured",
+ note="the pre-v0.11 public backend does not expose a prefill boundary",
+ ),
+ "decode": _phase(
+ "not_measured",
+ note="the pre-v0.11 public backend does not expose a decode boundary",
+ ),
+ "rollout_total": _phase("measured", values=measured_seconds),
+ "policy_sync": _phase(
+ "not_applicable",
+ note="hf_reference uses the actor already loaded in the trainer process",
+ ),
+ "teacher_scoring": _phase(
+ "not_measured",
+ note="rollout-only baseline cell; full-cycle measurement is a separate gate",
+ ),
+ "actor_update": _phase(
+ "not_measured",
+ note="rollout-only baseline cell; full-cycle measurement is a separate gate",
+ ),
+ "full_cycle": _phase(
+ "not_measured",
+ note="rollout-only baseline cell; no phase is represented as zero",
+ ),
+ "teardown": _phase(
+ "not_measured",
+ note="filled after the shared backend is closed",
+ ),
+ },
+ "rates": {
+ "time_to_first_token_seconds": None,
+ "prompt_tokens_per_second": prompt_tokens / median_seconds,
+ "output_tokens_per_second": generated_tokens / median_seconds,
+ },
+ "memory": {
+ "peak_allocated_bytes": int(torch.cuda.max_memory_allocated()),
+ "peak_reserved_bytes": int(torch.cuda.max_memory_reserved()),
+ "process_rss_bytes": _rss_bytes(),
+ "teardown_residual_allocated_bytes": None,
+ },
+ "output_token_ids_sha256": output_ids_digest,
+ "sampled_logprobs_sha256": logprobs_digest,
+ "oom_downshifts": 0,
+ "error": None,
+ }
+ except torch.OutOfMemoryError as exc:
+ torch.cuda.empty_cache()
+ return _failed_cell(
+ cell_id=cell_id,
+ prompt_length=prompt_length,
+ response_bound=response_bound,
+ samples_per_prompt=samples_per_prompt,
+ sampling=sampling_name,
+ status="oom",
+ error=f"{type(exc).__name__}: {exc}",
+ )
+ except Exception as exc:
+ return _failed_cell(
+ cell_id=cell_id,
+ prompt_length=prompt_length,
+ response_bound=response_bound,
+ samples_per_prompt=samples_per_prompt,
+ sampling=sampling_name,
+ status="failed",
+ error=f"{type(exc).__name__}: {exc}",
+ )
+
+
+def run(*, wheel: Path, output: Path, expected_commit: str) -> dict[str, Any]:
+ if not torch.cuda.is_available():
+ raise RuntimeError("rollout-runtime-v2 baseline requires one CUDA GPU")
+ if platform.system() != "Linux" or "microsoft" not in platform.release().lower():
+ raise RuntimeError("formal rollout-runtime-v2 baseline requires WSL2/Linux")
+ if _sha256(FROZEN_CALCULATOR) != FROZEN_CALCULATOR_SHA256:
+ raise RuntimeError("frozen calculator benchmark hash changed")
+ commit = _git("rev-parse", "HEAD")
+ if commit != expected_commit:
+ raise RuntimeError(f"expected source commit {expected_commit}, found {commit}")
+ if _git("status", "--porcelain"):
+ raise RuntimeError("formal baseline requires a clean worktree")
+ if not wheel.is_file():
+ raise FileNotFoundError(wheel)
+
+ prereg = yaml.safe_load(PREREGISTRATION.read_text(encoding="utf-8"))
+ if prereg["status"] != "preregistered_before_baseline_measurement":
+ raise RuntimeError("rollout runtime preregistration is not in its frozen initial state")
+ actor = prereg["models"]["actor"]
+ spec = StudentModelConfig(
+ model_id=actor["id"],
+ revision=actor["revision"],
+ tokenizer_revision=actor["tokenizer_revision"],
+ dtype=prereg["models"]["dtype"],
+ quantization=prereg["models"]["quantization"],
+ attn_implementation=prereg["models"]["attention_implementation"],
+ gradient_checkpointing=False,
+ )
+
+ started = time.perf_counter()
+ tokenizer = HFTokenizerAdapter.load(
+ spec.tokenizer_id or spec.model_id,
+ revision=spec.tokenizer_revision or spec.revision,
+ trust_remote_code=spec.trust_remote_code,
+ local_files_only=False,
+ )
+ backend = HFBackend.load(
+ spec,
+ device="cuda",
+ tokenizer=tokenizer,
+ trainable=False,
+ local_files_only=False,
+ )
+ torch.cuda.synchronize()
+ cold_start_seconds = time.perf_counter() - started
+ workload = prereg["workload"]
+ cells: list[dict[str, Any]] = []
+ for prompt_length in workload["prompt_lengths"]:
+ for response_bound in workload["response_bounds"]:
+ for samples_per_prompt in workload["samples_per_prompt"]:
+ for sampling in workload["sampling"]:
+ cells.append(
+ _cell(
+ backend,
+ tokenizer=tokenizer,
+ prompt_length=int(prompt_length),
+ response_bound=int(response_bound),
+ samples_per_prompt=int(samples_per_prompt),
+ sampling=sampling,
+ workload=workload,
+ cold_start_seconds=cold_start_seconds,
+ )
+ )
+
+ teardown_started = time.perf_counter()
+ backend.release()
+ del backend
+ del tokenizer
+ gc.collect()
+ torch.cuda.empty_cache()
+ torch.cuda.synchronize()
+ teardown_seconds = time.perf_counter() - teardown_started
+ residual = int(torch.cuda.memory_allocated())
+ for cell in cells:
+ cell["phases"]["teardown"] = _phase(
+ "measured",
+ values=[teardown_seconds],
+ note="shared backend teardown measurement repeated on each cell",
+ )
+ cell["memory"]["teardown_residual_allocated_bytes"] = residual
+
+ failures = [f"{cell['cell_id']}: {cell['error']}" for cell in cells if cell["error"]]
+ result = {
+ "schema_version": 1,
+ "name": "rollout-runtime-v2-hf-reference",
+ "measurement_status": "completed_with_failures" if failures else "measured_baseline",
+ "source": {
+ "commit": commit,
+ "dirty": False,
+ "miniverl_version": __version__,
+ "wheel_sha256": _sha256(wheel),
+ },
+ "preregistration_sha256": _sha256(PREREGISTRATION),
+ "workload_manifest_sha256": hashlib.sha256(
+ canonical_json(workload).encode("utf-8")
+ ).hexdigest(),
+ "frozen_calculator_sha256": FROZEN_CALCULATOR_SHA256,
+ "environment": _environment(),
+ "models": {
+ "actor": actor,
+ "teacher": prereg["models"]["teacher"],
+ "dtype": prereg["models"]["dtype"],
+ "quantization": prereg["models"]["quantization"],
+ },
+ "backend": {
+ "name": "hf_reference",
+ "version": str(_package_version("transformers")),
+ "reproducibility_class": "same_process_seeded_reference",
+ },
+ "cells": cells,
+ "failures": failures,
+ }
+ schema = json.loads(SCHEMA.read_text(encoding="utf-8"))
+ jsonschema.validate(result, schema)
+ write_json(output, result)
+ return result
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--wheel", type=Path, required=True)
+ parser.add_argument("--expected-commit", required=True)
+ parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
+ args = parser.parse_args()
+ result = run(
+ wheel=args.wheel.resolve(),
+ output=args.output.resolve(),
+ expected_commit=args.expected_commit,
+ )
+ print(json.dumps({"status": result["measurement_status"], "cells": len(result["cells"])}))
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/src/miniverl/__init__.py b/src/miniverl/__init__.py
index b7e2ecb..32749a4 100644
--- a/src/miniverl/__init__.py
+++ b/src/miniverl/__init__.py
@@ -14,6 +14,6 @@
from __future__ import annotations
-__version__ = "0.10.2.dev0"
+__version__ = "0.11.0.dev0"
__all__ = ["__version__"]
diff --git a/tests/unit/test_release_assets.py b/tests/unit/test_release_assets.py
index 75c661a..034f4dd 100644
--- a/tests/unit/test_release_assets.py
+++ b/tests/unit/test_release_assets.py
@@ -24,7 +24,7 @@ def _fixture(tmp_path: Path) -> tuple[Path, Path, Path, Path]:
qualification = tmp_path / "qualification"
candidate.mkdir(parents=True)
qualification.mkdir(parents=True)
- version = "0.10.2.dev0"
+ version = "0.11.0.dev0"
commit = "a" * 40
wheel = candidate / f"miniverl-{version}-py3-none-any.whl"
sdist = candidate / f"miniverl-{version}.tar.gz"
@@ -219,8 +219,8 @@ def test_builds_exact_canonical_layout_and_checks_it(tmp_path: Path) -> None:
output = _build(tmp_path)
expected = {
- "dist/miniverl-0.10.2.dev0-py3-none-any.whl",
- "dist/miniverl-0.10.2.dev0.tar.gz",
+ "dist/miniverl-0.11.0.dev0-py3-none-any.whl",
+ "dist/miniverl-0.11.0.dev0.tar.gz",
"SHA256SUMS",
"candidate-manifest.json",
"release-verification.json",
diff --git a/tests/unit/test_rollout_runtime_v2_benchmark.py b/tests/unit/test_rollout_runtime_v2_benchmark.py
new file mode 100644
index 0000000..83e72a1
--- /dev/null
+++ b/tests/unit/test_rollout_runtime_v2_benchmark.py
@@ -0,0 +1,136 @@
+"""Preregistration and result contracts for Rollout Runtime v2."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import jsonschema
+import yaml
+
+ROOT = Path(__file__).resolve().parents[2]
+PREREGISTRATION = ROOT / "benchmarks/preregistration/rollout-runtime-v2.yaml"
+SCHEMA = ROOT / "benchmarks/schema/rollout-runtime-v2.schema.json"
+FROZEN = ROOT / "benchmarks/results/gpu-calc-hard-equal-update-v2.json"
+
+
+def test_rollout_runtime_v2_workload_is_preregistered_before_baseline() -> None:
+ payload = yaml.safe_load(PREREGISTRATION.read_text(encoding="utf-8"))
+
+ assert payload["status"] == "preregistered_before_baseline_measurement"
+ assert payload["models"]["actor"]["revision"] == ("c1899de289a04d12100db370d81485cdf75e47ca")
+ assert payload["models"]["teacher"]["revision"] == ("70d244cc86ccca08cf5af4e1e306ecf908b1ad5e")
+ assert payload["workload"]["prompt_lengths"] == [128, 512]
+ assert payload["workload"]["response_bounds"] == [64, 256, 512]
+ assert payload["workload"]["samples_per_prompt"] == [1, 4]
+ assert {row["name"] for row in payload["workload"]["sampling"]} == {
+ "greedy",
+ "seeded_stochastic",
+ }
+ assert payload["performance_gates"]["hf_cached_speedup_over_hf_reference"] == {
+ "response_256": 2.0,
+ "response_512": 2.0,
+ }
+
+
+def test_rollout_runtime_v2_preserves_frozen_calculator() -> None:
+ assert hashlib.sha256(FROZEN.read_bytes()).hexdigest() == (
+ "53fc1d4d5b7adee09618d77ad62d4086ba56b78569832d6fc7c3bcd5c2695bbc"
+ )
+
+
+def _phase(status: str, measured: bool = False) -> dict[str, object]:
+ payload: dict[str, object] = {"status": status}
+ if measured:
+ payload.update({"median_seconds": 1.0, "minimum_seconds": 0.9})
+ return payload
+
+
+def test_rollout_runtime_v2_schema_keeps_unavailable_phases_distinct_from_zero() -> None:
+ phases = {
+ "cold_start": _phase("measured", measured=True),
+ "prefill": _phase("not_measured"),
+ "decode": _phase("not_measured"),
+ "rollout_total": _phase("measured", measured=True),
+ "policy_sync": _phase("not_applicable"),
+ "teacher_scoring": _phase("not_measured"),
+ "actor_update": _phase("not_measured"),
+ "full_cycle": _phase("not_measured"),
+ "teardown": _phase("measured", measured=True),
+ }
+ result = {
+ "schema_version": 1,
+ "name": "rollout-runtime-v2-hf-reference",
+ "measurement_status": "measured_baseline",
+ "source": {
+ "commit": "a" * 40,
+ "dirty": False,
+ "miniverl_version": "0.11.0.dev0",
+ "wheel_sha256": "b" * 64,
+ },
+ "preregistration_sha256": "c" * 64,
+ "workload_manifest_sha256": "d" * 64,
+ "frozen_calculator_sha256": (
+ "53fc1d4d5b7adee09618d77ad62d4086ba56b78569832d6fc7c3bcd5c2695bbc"
+ ),
+ "environment": {},
+ "models": {
+ "actor": {
+ "id": "Qwen/Qwen3-0.6B",
+ "revision": "e" * 40,
+ "tokenizer_revision": "e" * 40,
+ },
+ "teacher": {
+ "id": "Qwen/Qwen3-1.7B",
+ "revision": "f" * 40,
+ "tokenizer_revision": "f" * 40,
+ },
+ "dtype": "bfloat16",
+ "quantization": "nf4",
+ },
+ "backend": {
+ "name": "hf_reference",
+ "version": "5.14.1",
+ "reproducibility_class": "same_process_seeded_reference",
+ },
+ "cells": [
+ {
+ "cell_id": "p128-r64-n1-greedy",
+ "prompt_length": 128,
+ "response_bound": 64,
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed",
+ "counts": {
+ "logical_prompts": 4,
+ "generated_trajectories": 4,
+ "prompt_tokens": 512,
+ "generated_tokens": 256,
+ "physical_batches": 1,
+ },
+ "phases": phases,
+ "rates": {
+ "time_to_first_token_seconds": None,
+ "prompt_tokens_per_second": 512.0,
+ "output_tokens_per_second": 256.0,
+ },
+ "memory": {
+ "peak_allocated_bytes": 1,
+ "peak_reserved_bytes": 2,
+ "process_rss_bytes": 3,
+ "teardown_residual_allocated_bytes": 0,
+ },
+ "output_token_ids_sha256": "1" * 64,
+ "sampled_logprobs_sha256": "2" * 64,
+ "oom_downshifts": 0,
+ "error": None,
+ }
+ ],
+ "failures": [],
+ }
+
+ schema = json.loads(SCHEMA.read_text(encoding="utf-8"))
+ jsonschema.validate(result, schema)
+ for name in ("prefill", "decode", "teacher_scoring", "actor_update", "full_cycle"):
+ assert "median_seconds" not in phases[name]
diff --git a/tests/unit/test_v1_readiness.py b/tests/unit/test_v1_readiness.py
index dc06e2c..ad26a61 100644
--- a/tests/unit/test_v1_readiness.py
+++ b/tests/unit/test_v1_readiness.py
@@ -42,5 +42,5 @@ def test_polish_does_not_change_version_or_beta_classifier() -> None:
state = yaml.safe_load((ROOT / "release-state.yaml").read_text(encoding="utf-8"))
pyproject = (ROOT / "pyproject.toml").read_text(encoding="utf-8")
assert state["stable"]["version"] == "0.10.1"
- assert state["development"]["version"] == "0.10.2.dev0"
+ assert state["development"]["version"] == "0.11.0.dev0"
assert "Development Status :: 4 - Beta" in pyproject
From 8e5ebdadf9accf13e17418260092a8917067e386 Mon Sep 17 00:00:00 2001
From: Daoyuan Li <94409450+DaoyuanLi2816@users.noreply.github.com>
Date: Sat, 29 Aug 2026 03:22:49 -0700
Subject: [PATCH 2/2] Freeze the HF rollout reference baseline
---
CHANGELOG.md | 2 +
benchmarks/README.md | 1 +
.../rollout-runtime-v2/hf-reference-raw.json | 1802 ++++++++++++++++
.../rollout-runtime-v2-hf-reference.json | 1812 +++++++++++++++++
.../schema/rollout-runtime-v2.schema.json | 23 +
docs/benchmarks/rollout-runtime-v2.md | 72 +
docs/release-checklist.md | 5 +-
mkdocs.yml | 1 +
scripts/finalize_rollout_runtime_baseline.py | 144 ++
tests/unit/test_packaging.py | 1 +
.../unit/test_rollout_runtime_v2_benchmark.py | 65 +
11 files changed, 3927 insertions(+), 1 deletion(-)
create mode 100644 benchmarks/evidence/rollout-runtime-v2/hf-reference-raw.json
create mode 100644 benchmarks/results/rollout-runtime-v2-hf-reference.json
create mode 100644 docs/benchmarks/rollout-runtime-v2.md
create mode 100644 scripts/finalize_rollout_runtime_baseline.py
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f5dee61..a06bcd3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,8 @@ All notable changes to miniVERL are recorded here. The format follows
RTX 4080 rollout workload before changing generation behavior.
- Added an exact-source competitive landscape that separates upstream claims,
miniVERL's current state and measurements that have not yet been run.
+- Froze the 24-cell pre-v0.11 `hf_reference` actor-rollout baseline on the WSL2
+ RTX 4080, with exact wheel, weight, policy and raw-measurement identity.
### Documentation narrative
diff --git a/benchmarks/README.md b/benchmarks/README.md
index 8faecbc..9a11731 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -80,6 +80,7 @@ Listed so you can check that this repository does not.
| File | Hardware | What it shows |
| --- | --- | --- |
+| `results/rollout-runtime-v2-hf-reference.json` | WSL2 RTX 4080 16 GB | Pre-v0.11 actor-rollout systems baseline: all 24 preregistered prompt/response/n/sampling cells completed. It freezes throughput and memory for the future `hf_cached` comparison; teacher scoring, updates, full-cycle timing and typed grouped semantics are not measured here. [Method, table and boundaries.](../docs/benchmarks/rollout-runtime-v2.md) |
| `results/alignment-external-v1.json` | RTX 4080 16 GB | **Preregistered early stop, not a method comparison.** Two declared lineages and eight candidates all measured 0/64 retained JSONNav utility against an unchanged 20% floor. No checkpoint, teacher, continuation arm or final-test result exists. [Study, correction provenance and evaluator boundary.](../docs/alignment-external/alignment-external-v1.md) |
| `results/alignment-lab-v1.json` | RTX 4080 16 GB | Alignment Lab v1: six methods from one Qwen3-0.6B SFT checkpoint, three seeds and 48 paired policy tasks per arm. The SFT start saturated alignment and utility; no continuation method improved it, so the pilot recommends no online teacher querying. [Report, figures and caveats.](../docs/alignment-lab/alignment-lab-v1.md) |
| `results/consumer-runtime-v1.json` | RTX 4080 16 GB | Preregistered eight-cell systems matrix for sequential/batch-2/batch-4/auto updates under dual-model and shared-backbone ownership. Batch-4 reached 3.866 and 3.475 trajectories/s at 3.035 and 2.227 GiB reserved; all equivalence gates passed. [Figure, method and caveats.](../docs/consumer-runtime-v1.md) |
diff --git a/benchmarks/evidence/rollout-runtime-v2/hf-reference-raw.json b/benchmarks/evidence/rollout-runtime-v2/hf-reference-raw.json
new file mode 100644
index 0000000..67093c5
--- /dev/null
+++ b/benchmarks/evidence/rollout-runtime-v2/hf-reference-raw.json
@@ -0,0 +1,1802 @@
+{
+ "backend": {
+ "name": "hf_reference",
+ "reproducibility_class": "same_process_seeded_reference",
+ "version": "5.14.1"
+ },
+ "cells": [
+ {
+ "cell_id": "p128-r64-n1-greedy",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 572068864,
+ "peak_reserved_bytes": 1109393408,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 2.682791788000003,
+ "minimum_seconds": 2.658286367999999,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 95.42298479705937,
+ "prompt_tokens_per_second": 190.84596959411874,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "1e08a89c7b3790ce57c3f26d242c0cc91c11df1eeec95b2a2a00ad2afd17d746",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r64-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 576205312,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 8.552983923,
+ "minimum_seconds": 8.483651064,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 29.931074617314,
+ "prompt_tokens_per_second": 59.862149234628,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "ba2f11193cd4eecb8e13f902cb1f94be663a23fa8604436173c7e8ac96885339",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r64-n4-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 572068864,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 10.549273207999988,
+ "minimum_seconds": 10.186481839999999,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 97.06829843248867,
+ "prompt_tokens_per_second": 194.13659686497735,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "ac873b82dc6266f08d49daa8851ae5ff969a9502fc09d0c46f0f11ef3fc7a983",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r64-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 576205312,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 34.194360034,
+ "minimum_seconds": 33.98181499500001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 29.94645897691375,
+ "prompt_tokens_per_second": 59.8929179538275,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "791ccbc8d12dd8173081df20a215540d059386148e537b585a9d189b1753880b",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n1-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 590592000,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 10.681579509000017,
+ "minimum_seconds": 10.601817451000045,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 95.86597180100608,
+ "prompt_tokens_per_second": 47.93298590050304,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "f0934e8f8a655f7db7a6c5fe450685ae02a92becbe1a11963b3178b5f991921b",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 598225408,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 34.191396914999984,
+ "minimum_seconds": 34.07746694100001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 29.949054218102585,
+ "prompt_tokens_per_second": 14.974527109051293,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "103374fb70459e305d3e95b24cede77ebe45c02c5f6235ee07972ccbe164c934",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n4-greedy",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 590592000,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 44.35223904600002,
+ "minimum_seconds": 41.96331140099994,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 92.3515946004851,
+ "prompt_tokens_per_second": 46.17579730024255,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "e5c0366e55822136810646af6f6a2ec1de385daf66816217678c76dc09145d88",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 598225408,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 136.20863945600013,
+ "minimum_seconds": 136.123254523,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 30.07151393890211,
+ "prompt_tokens_per_second": 15.035756969451056,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "facbbe2eb781282a5e9dc8b3667f98828457f64d3e222c6aec076a88ec5ff1d1",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n1-greedy",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 618349568,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 21.984175283000013,
+ "minimum_seconds": 21.751613103999944,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 93.15791807681244,
+ "prompt_tokens_per_second": 23.28947951920311,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "044bcce426878c05d803111ef04848dc025b84d1f46a0001838fecad8ace7792",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 67.754382588,
+ "minimum_seconds": 67.33902477300012,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 30.226826985546495,
+ "prompt_tokens_per_second": 7.556706746386624,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "d68a712f6a3a96e323d054d7918943fc9397399a6a0cc18628947a4749034719",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n4-greedy",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 618349568,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 88.1730873009999,
+ "minimum_seconds": 86.93808670099997,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 92.90816790881611,
+ "prompt_tokens_per_second": 23.227041977204028,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "fa8462caa7158d8ca5322eabd4df3c9a82db7be5f87a2952a93af96572a23606",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 270.3976930829999,
+ "minimum_seconds": 270.2917211260001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 30.296116459416037,
+ "prompt_tokens_per_second": 7.574029114854009,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "269cef51deb330312a1e377689cd9d4c40a7a3af3f494cf5712c49e14026fa82",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n1-greedy",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 611695104,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 2.7622460959996715,
+ "minimum_seconds": 2.755931521000093,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 92.67820139948546,
+ "prompt_tokens_per_second": 741.4256111958837,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "1295404c7e252083aaad1026b97935061f37c40d2cad4675a1fc154e5a4fbba9",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 8.455835185000069,
+ "minimum_seconds": 8.422462780999922,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.27495148606044,
+ "prompt_tokens_per_second": 242.19961188848353,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "b9ea95432739b2d0767f01ff6803048228f69992364297066cfcd4133000db3e",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n4-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 611695104,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 12.218045545999757,
+ "minimum_seconds": 11.155840058000194,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 83.81045856677643,
+ "prompt_tokens_per_second": 670.4836685342115,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "57edec6395dd88abd24e70047e0adca43f8a58876781092fa51c3c00e7518b36",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 33.8932466629999,
+ "minimum_seconds": 33.6279644719998,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.212508414482045,
+ "prompt_tokens_per_second": 241.70006731585636,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "b75bb614200673299c50f5478413793e3ae9f1ddf2f427c5b12d8dd78500af8d",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n1-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 631888384,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 12.784149807999711,
+ "minimum_seconds": 12.757599734999985,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 80.09918652230043,
+ "prompt_tokens_per_second": 160.19837304460086,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "a57f17956fe28fce722be3d3848cc15a065c03f9eb250f204ec2c421f9faeb77",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 643374592,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 33.78232267999965,
+ "minimum_seconds": 33.667141740999796,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.31171094124457,
+ "prompt_tokens_per_second": 60.62342188248914,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "3a7abb1408460217b6ce6cf4fd0621da14eeeead1407e00d1b44822d01bcec68",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n4-greedy",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 631888384,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 53.027317352999944,
+ "minimum_seconds": 51.61795949599991,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 77.24320603912795,
+ "prompt_tokens_per_second": 154.4864120782559,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "bb3fdbcfde4e043322d0706454f7b8fa31ca65df6ae80ce5065875624d3af8ff",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 643374592,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 136.25704416500002,
+ "minimum_seconds": 135.77568775700001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.060831167304364,
+ "prompt_tokens_per_second": 60.12166233460873,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "ed2ba774a231432d735974874af89dfbab5b9929ab5cc7caa8f455be5b18743f",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n1-greedy",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 659321344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 30.89718044900019,
+ "minimum_seconds": 30.822854752999774,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 66.28436544171045,
+ "prompt_tokens_per_second": 66.28436544171045,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "6859cbfc45117100cd52c0ef371e004ee43bf3b5fa0e3e84d763936648f0b84b",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 671865344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 68.44970350299991,
+ "minimum_seconds": 67.86870040000031,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 29.919778979177657,
+ "prompt_tokens_per_second": 29.919778979177657,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "7429ca8d21a239f77f986b028f5bf6b43aa75b7300aedbc644be9b3d65dda822",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n4-greedy",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 659321344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 123.62770391200047,
+ "minimum_seconds": 122.53081656099948,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 66.26346474760345,
+ "prompt_tokens_per_second": 66.26346474760345,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "d9059ffe4d8ef9786d3889a6873903ffef715882fd97f1a574c1e79b417f048d",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 671865344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 270.23090325500016,
+ "minimum_seconds": 270.1274789749996,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.31481559409109,
+ "prompt_tokens_per_second": 30.31481559409109,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "23fa6e0641892260aabc0d17d8ff67d0d90d2a13bf1159d03b7b8ca5b773d024",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ }
+ ],
+ "environment": {
+ "cuda_runtime": "13.0",
+ "gpu": "NVIDIA GeForce RTX 4080",
+ "gpu_total_memory_bytes": 17170956288,
+ "packages": {
+ "accelerate": "1.14.0",
+ "bitsandbytes": "0.50.0",
+ "peft": "0.18.0",
+ "torch": "2.13.0+cu130",
+ "transformers": "5.14.1"
+ },
+ "platform": "Linux-6.18.33.2-microsoft-standard-WSL2-x86_64-with-glibc2.43",
+ "python": "3.12.13"
+ },
+ "failures": [],
+ "frozen_calculator_sha256": "53fc1d4d5b7adee09618d77ad62d4086ba56b78569832d6fc7c3bcd5c2695bbc",
+ "measurement_status": "measured_baseline",
+ "models": {
+ "actor": {
+ "id": "Qwen/Qwen3-0.6B",
+ "revision": "c1899de289a04d12100db370d81485cdf75e47ca",
+ "tokenizer_revision": "c1899de289a04d12100db370d81485cdf75e47ca"
+ },
+ "dtype": "bfloat16",
+ "quantization": "nf4",
+ "teacher": {
+ "id": "Qwen/Qwen3-1.7B",
+ "revision": "70d244cc86ccca08cf5af4e1e306ecf908b1ad5e",
+ "tokenizer_revision": "70d244cc86ccca08cf5af4e1e306ecf908b1ad5e"
+ }
+ },
+ "name": "rollout-runtime-v2-hf-reference",
+ "preregistration_sha256": "8cc3ba738c69b59ed19c22c1de874fd00249404198a3e05983477dc8899bb7e5",
+ "schema_version": 1,
+ "source": {
+ "commit": "0d6e0070ae73ef35f718aec3624ee5263ac96e3a",
+ "dirty": false,
+ "miniverl_version": "0.11.0.dev0",
+ "wheel_sha256": "0256bd9e63ca6ed52999a5073a3577a008581a8d4418062314750d86f21cd5fe"
+ },
+ "workload_manifest_sha256": "9157dcdc84545d4c4e55b97084c2a93b5bc0f55d7188f36b77389b4356c09c68"
+}
diff --git a/benchmarks/results/rollout-runtime-v2-hf-reference.json b/benchmarks/results/rollout-runtime-v2-hf-reference.json
new file mode 100644
index 0000000..ebba731
--- /dev/null
+++ b/benchmarks/results/rollout-runtime-v2-hf-reference.json
@@ -0,0 +1,1812 @@
+{
+ "backend": {
+ "name": "hf_reference",
+ "reproducibility_class": "same_process_seeded_reference",
+ "version": "5.14.1"
+ },
+ "cells": [
+ {
+ "cell_id": "p128-r64-n1-greedy",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 572068864,
+ "peak_reserved_bytes": 1109393408,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 2.682791788000003,
+ "minimum_seconds": 2.658286367999999,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 95.42298479705937,
+ "prompt_tokens_per_second": 190.84596959411874,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "1e08a89c7b3790ce57c3f26d242c0cc91c11df1eeec95b2a2a00ad2afd17d746",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r64-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 576205312,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 8.552983923,
+ "minimum_seconds": 8.483651064,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 29.931074617314,
+ "prompt_tokens_per_second": 59.862149234628,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "ba2f11193cd4eecb8e13f902cb1f94be663a23fa8604436173c7e8ac96885339",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r64-n4-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 572068864,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 10.549273207999988,
+ "minimum_seconds": 10.186481839999999,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 97.06829843248867,
+ "prompt_tokens_per_second": 194.13659686497735,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "ac873b82dc6266f08d49daa8851ae5ff969a9502fc09d0c46f0f11ef3fc7a983",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r64-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 576205312,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 34.194360034,
+ "minimum_seconds": 33.98181499500001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 29.94645897691375,
+ "prompt_tokens_per_second": 59.8929179538275,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "791ccbc8d12dd8173081df20a215540d059386148e537b585a9d189b1753880b",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n1-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 590592000,
+ "peak_reserved_bytes": 1130364928,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 10.681579509000017,
+ "minimum_seconds": 10.601817451000045,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 95.86597180100608,
+ "prompt_tokens_per_second": 47.93298590050304,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "f0934e8f8a655f7db7a6c5fe450685ae02a92becbe1a11963b3178b5f991921b",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 598225408,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 34.191396914999984,
+ "minimum_seconds": 34.07746694100001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 29.949054218102585,
+ "prompt_tokens_per_second": 14.974527109051293,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "103374fb70459e305d3e95b24cede77ebe45c02c5f6235ee07972ccbe164c934",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n4-greedy",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 590592000,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 44.35223904600002,
+ "minimum_seconds": 41.96331140099994,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 92.3515946004851,
+ "prompt_tokens_per_second": 46.17579730024255,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "e5c0366e55822136810646af6f6a2ec1de385daf66816217678c76dc09145d88",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r256-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 598225408,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 136.20863945600013,
+ "minimum_seconds": 136.123254523,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 30.07151393890211,
+ "prompt_tokens_per_second": 15.035756969451056,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "facbbe2eb781282a5e9dc8b3667f98828457f64d3e222c6aec076a88ec5ff1d1",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n1-greedy",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 618349568,
+ "peak_reserved_bytes": 1163919360,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 21.984175283000013,
+ "minimum_seconds": 21.751613103999944,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 93.15791807681244,
+ "prompt_tokens_per_second": 23.28947951920311,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "044bcce426878c05d803111ef04848dc025b84d1f46a0001838fecad8ace7792",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 512
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 67.754382588,
+ "minimum_seconds": 67.33902477300012,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 30.226826985546495,
+ "prompt_tokens_per_second": 7.556706746386624,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "d68a712f6a3a96e323d054d7918943fc9397399a6a0cc18628947a4749034719",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n4-greedy",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 618349568,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 88.1730873009999,
+ "minimum_seconds": 86.93808670099997,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 92.90816790881611,
+ "prompt_tokens_per_second": 23.227041977204028,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "fa8462caa7158d8ca5322eabd4df3c9a82db7be5f87a2952a93af96572a23606",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p128-r512-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 270.3976930829999,
+ "minimum_seconds": 270.2917211260001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 128,
+ "rates": {
+ "output_tokens_per_second": 30.296116459416037,
+ "prompt_tokens_per_second": 7.574029114854009,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "269cef51deb330312a1e377689cd9d4c40a7a3af3f494cf5712c49e14026fa82",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n1-greedy",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 611695104,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 2.7622460959996715,
+ "minimum_seconds": 2.755931521000093,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 92.67820139948546,
+ "prompt_tokens_per_second": 741.4256111958837,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "1295404c7e252083aaad1026b97935061f37c40d2cad4675a1fc154e5a4fbba9",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 256,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "cd9f13d9e943573baeb2d4e1dd04b122c4faceda6069544c4a48df4a673d8643",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 8.455835185000069,
+ "minimum_seconds": 8.422462780999922,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.27495148606044,
+ "prompt_tokens_per_second": 242.19961188848353,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "b9ea95432739b2d0767f01ff6803048228f69992364297066cfcd4133000db3e",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n4-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 611695104,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 12.218045545999757,
+ "minimum_seconds": 11.155840058000194,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 83.81045856677643,
+ "prompt_tokens_per_second": 670.4836685342115,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "57edec6395dd88abd24e70047e0adca43f8a58876781092fa51c3c00e7518b36",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r64-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 641536512,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "3b4b83de35b1d649fe3f49cf2489de7a434a97304abb50ee7ef985da4ea3b328",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 33.8932466629999,
+ "minimum_seconds": 33.6279644719998,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.212508414482045,
+ "prompt_tokens_per_second": 241.70006731585636,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 64,
+ "sampled_logprobs_sha256": "b75bb614200673299c50f5478413793e3ae9f1ddf2f427c5b12d8dd78500af8d",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n1-greedy",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 631888384,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 12.784149807999711,
+ "minimum_seconds": 12.757599734999985,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 80.09918652230043,
+ "prompt_tokens_per_second": 160.19837304460086,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "a57f17956fe28fce722be3d3848cc15a065c03f9eb250f204ec2c421f9faeb77",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 1024,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 643374592,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "711427fff6e3d357944a8bc254ed4cae8b33627122172a8d8e0d7724dc22c321",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 33.78232267999965,
+ "minimum_seconds": 33.667141740999796,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.31171094124457,
+ "prompt_tokens_per_second": 60.62342188248914,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "3a7abb1408460217b6ce6cf4fd0621da14eeeead1407e00d1b44822d01bcec68",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n4-greedy",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 631888384,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 53.027317352999944,
+ "minimum_seconds": 51.61795949599991,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 77.24320603912795,
+ "prompt_tokens_per_second": 154.4864120782559,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "bb3fdbcfde4e043322d0706454f7b8fa31ca65df6ae80ce5065875624d3af8ff",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r256-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 4096,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 643374592,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "eef961f1441414411acf4c676a6720a72986f1a635f4c62431adf91b9b288d13",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 136.25704416500002,
+ "minimum_seconds": 135.77568775700001,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.060831167304364,
+ "prompt_tokens_per_second": 60.12166233460873,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 256,
+ "sampled_logprobs_sha256": "ed2ba774a231432d735974874af89dfbab5b9929ab5cc7caa8f455be5b18743f",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n1-greedy",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 659321344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 30.89718044900019,
+ "minimum_seconds": 30.822854752999774,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 66.28436544171045,
+ "prompt_tokens_per_second": 66.28436544171045,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "6859cbfc45117100cd52c0ef371e004ee43bf3b5fa0e3e84d763936648f0b84b",
+ "samples_per_prompt": 1,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n1-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 2048,
+ "generated_trajectories": 4,
+ "logical_prompts": 4,
+ "physical_batches": 1,
+ "prompt_tokens": 2048
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 671865344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "fdf6053d6a62183ea73d5a3e6da66538b71bcae75835bd826ecf81ddefa4a1b5",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 68.44970350299991,
+ "minimum_seconds": 67.86870040000031,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 29.919778979177657,
+ "prompt_tokens_per_second": 29.919778979177657,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "7429ca8d21a239f77f986b028f5bf6b43aa75b7300aedbc644be9b3d65dda822",
+ "samples_per_prompt": 1,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n4-greedy",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 659321344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 123.62770391200047,
+ "minimum_seconds": 122.53081656099948,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 66.26346474760345,
+ "prompt_tokens_per_second": 66.26346474760345,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "d9059ffe4d8ef9786d3889a6873903ffef715882fd97f1a574c1e79b417f048d",
+ "samples_per_prompt": 4,
+ "sampling": "greedy",
+ "status": "completed"
+ },
+ {
+ "cell_id": "p512-r512-n4-seeded_stochastic",
+ "counts": {
+ "generated_tokens": 8192,
+ "generated_trajectories": 16,
+ "logical_prompts": 4,
+ "physical_batches": 4,
+ "prompt_tokens": 8192
+ },
+ "error": null,
+ "memory": {
+ "peak_allocated_bytes": 671865344,
+ "peak_reserved_bytes": 1166016512,
+ "process_rss_bytes": 2620805120,
+ "teardown_residual_allocated_bytes": 8520704
+ },
+ "oom_downshifts": 0,
+ "output_token_ids_sha256": "9d36364e8c8bb02886b0de3de5708858843f570413918901df1afe2fcebaf47d",
+ "phases": {
+ "actor_update": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "cold_start": {
+ "median_seconds": 8.762755541000004,
+ "minimum_seconds": 8.762755541000004,
+ "note": "shared actor/tokenizer load measurement repeated on each cell",
+ "status": "measured"
+ },
+ "decode": {
+ "note": "the pre-v0.11 public backend does not expose a decode boundary",
+ "status": "not_measured"
+ },
+ "full_cycle": {
+ "note": "rollout-only baseline cell; no phase is represented as zero",
+ "status": "not_measured"
+ },
+ "policy_sync": {
+ "note": "hf_reference uses the actor already loaded in the trainer process",
+ "status": "not_applicable"
+ },
+ "prefill": {
+ "note": "the pre-v0.11 public backend does not expose a prefill boundary",
+ "status": "not_measured"
+ },
+ "rollout_total": {
+ "median_seconds": 270.23090325500016,
+ "minimum_seconds": 270.1274789749996,
+ "status": "measured"
+ },
+ "teacher_scoring": {
+ "note": "rollout-only baseline cell; full-cycle measurement is a separate gate",
+ "status": "not_measured"
+ },
+ "teardown": {
+ "median_seconds": 0.2742385410001589,
+ "minimum_seconds": 0.2742385410001589,
+ "note": "shared backend teardown measurement repeated on each cell",
+ "status": "measured"
+ }
+ },
+ "prompt_length": 512,
+ "rates": {
+ "output_tokens_per_second": 30.31481559409109,
+ "prompt_tokens_per_second": 30.31481559409109,
+ "time_to_first_token_seconds": null
+ },
+ "response_bound": 512,
+ "sampled_logprobs_sha256": "23fa6e0641892260aabc0d17d8ff67d0d90d2a13bf1159d03b7b8ca5b773d024",
+ "samples_per_prompt": 4,
+ "sampling": "seeded_stochastic",
+ "status": "completed"
+ }
+ ],
+ "environment": {
+ "cuda_runtime": "13.0",
+ "driver_version": "596.49",
+ "gpu": "NVIDIA GeForce RTX 4080",
+ "gpu_total_memory_bytes": 17170956288,
+ "packages": {
+ "accelerate": "1.14.0",
+ "bitsandbytes": "0.50.0",
+ "peft": "0.18.0",
+ "torch": "2.13.0+cu130",
+ "transformers": "5.14.1"
+ },
+ "platform": "Linux-6.18.33.2-microsoft-standard-WSL2-x86_64-with-glibc2.43",
+ "python": "3.12.13"
+ },
+ "failures": [],
+ "frozen_calculator_sha256": "53fc1d4d5b7adee09618d77ad62d4086ba56b78569832d6fc7c3bcd5c2695bbc",
+ "measurement_status": "measured_baseline",
+ "models": {
+ "actor": {
+ "id": "Qwen/Qwen3-0.6B",
+ "revision": "c1899de289a04d12100db370d81485cdf75e47ca",
+ "tokenizer_revision": "c1899de289a04d12100db370d81485cdf75e47ca"
+ },
+ "dtype": "bfloat16",
+ "quantization": "nf4",
+ "teacher": {
+ "id": "Qwen/Qwen3-1.7B",
+ "revision": "70d244cc86ccca08cf5af4e1e306ecf908b1ad5e",
+ "tokenizer_revision": "70d244cc86ccca08cf5af4e1e306ecf908b1ad5e"
+ }
+ },
+ "name": "rollout-runtime-v2-hf-reference",
+ "policy_identity": {
+ "adapter_digest_sha256": null,
+ "base_revision": "c1899de289a04d12100db370d81485cdf75e47ca",
+ "base_weight_digest_sha256": "b29cd98b83f9bddc7ec8943be5f142243e956f448f13456847849e5b8615b413",
+ "identity_digest_sha256": "926e099c2bfd349c1738cc81adc657d16604f86e7fabbe49d37d335a906c84de",
+ "policy_version": 0,
+ "profile_identity": "rollout-runtime-v2-hf-reference-baseline-v1"
+ },
+ "preregistration_sha256": "8cc3ba738c69b59ed19c22c1de874fd00249404198a3e05983477dc8899bb7e5",
+ "raw_measurement_sha256": "2e303eabb559b843d25377a7c72e0aeb0219eec7eb8bc109c0419839b3251170",
+ "schema_version": 1,
+ "source": {
+ "commit": "0d6e0070ae73ef35f718aec3624ee5263ac96e3a",
+ "dirty": false,
+ "miniverl_version": "0.11.0.dev0",
+ "wheel_sha256": "0256bd9e63ca6ed52999a5073a3577a008581a8d4418062314750d86f21cd5fe"
+ },
+ "workload_manifest_sha256": "9157dcdc84545d4c4e55b97084c2a93b5bc0f55d7188f36b77389b4356c09c68"
+}
diff --git a/benchmarks/schema/rollout-runtime-v2.schema.json b/benchmarks/schema/rollout-runtime-v2.schema.json
index f8bd3ef..e339d58 100644
--- a/benchmarks/schema/rollout-runtime-v2.schema.json
+++ b/benchmarks/schema/rollout-runtime-v2.schema.json
@@ -9,12 +9,14 @@
"name",
"measurement_status",
"source",
+ "raw_measurement_sha256",
"preregistration_sha256",
"workload_manifest_sha256",
"frozen_calculator_sha256",
"environment",
"models",
"backend",
+ "policy_identity",
"cells",
"failures"
],
@@ -25,6 +27,7 @@
"enum": ["measured_baseline", "completed_with_failures"]
},
"source": {"$ref": "#/$defs/source"},
+ "raw_measurement_sha256": {"$ref": "#/$defs/sha256"},
"preregistration_sha256": {"$ref": "#/$defs/sha256"},
"workload_manifest_sha256": {"$ref": "#/$defs/sha256"},
"frozen_calculator_sha256": {
@@ -52,6 +55,26 @@
"reproducibility_class": {"const": "same_process_seeded_reference"}
}
},
+ "policy_identity": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": [
+ "policy_version",
+ "profile_identity",
+ "base_revision",
+ "base_weight_digest_sha256",
+ "adapter_digest_sha256",
+ "identity_digest_sha256"
+ ],
+ "properties": {
+ "policy_version": {"const": 0},
+ "profile_identity": {"const": "rollout-runtime-v2-hf-reference-baseline-v1"},
+ "base_revision": {"type": "string", "pattern": "^[0-9a-f]{40}$"},
+ "base_weight_digest_sha256": {"$ref": "#/$defs/sha256"},
+ "adapter_digest_sha256": {"type": "null"},
+ "identity_digest_sha256": {"$ref": "#/$defs/sha256"}
+ }
+ },
"cells": {
"type": "array",
"minItems": 1,
diff --git a/docs/benchmarks/rollout-runtime-v2.md b/docs/benchmarks/rollout-runtime-v2.md
new file mode 100644
index 0000000..69321fe
--- /dev/null
+++ b/docs/benchmarks/rollout-runtime-v2.md
@@ -0,0 +1,72 @@
+# Rollout Runtime v2: frozen HF reference baseline
+
+The pre-v0.11 Hugging Face path is now frozen as the compatibility and
+performance baseline for Rollout Runtime v2. All 24 preregistered cells
+completed on one WSL2 RTX 4080 without an OOM or discarded cell.
+
+This result measures actor rollout only. It is not a task-quality experiment,
+does not include teacher scoring or an optimizer update, and does not yet
+exercise typed grouped-sample semantics.
+
+## Frozen setup
+
+| Item | Exact value |
+| --- | --- |
+| Source | `0d6e0070ae73ef35f718aec3624ee5263ac96e3a` |
+| Candidate wheel | `0256bd9e63ca6ed52999a5073a3577a008581a8d4418062314750d86f21cd5fe` |
+| Actor | `Qwen/Qwen3-0.6B` at `c1899de289a04d12100db370d81485cdf75e47ca` |
+| Weight payload digest | `b29cd98b83f9bddc7ec8943be5f142243e956f448f13456847849e5b8615b413` |
+| Runtime | Python 3.12.13, Torch 2.13.0+cu130, Transformers 5.14.1, NF4/BF16 |
+| GPU / driver | NVIDIA GeForce RTX 4080 16 GiB / 596.49 |
+| Workload | 4 logical prompts; prompt 128/512; response 64/256/512; `n=1/4`; greedy and seeded stochastic |
+
+## Measured rollout throughput
+
+Every row generated the full configured response bound. Rates use actual
+generated tokens and median wall time over three measured repetitions after
+one warmup.
+
+| Prompt | Response | Samples/prompt | Greedy tokens/s | Seeded stochastic tokens/s | Peak reserved GiB |
+| ---: | ---: | ---: | ---: | ---: | ---: |
+| 128 | 64 | 1 | 95.42 | 29.93 | 1.053 |
+| 128 | 64 | 4 | 97.07 | 29.95 | 1.053 |
+| 128 | 256 | 1 | 95.87 | 29.95 | 1.084 |
+| 128 | 256 | 4 | 92.35 | 30.07 | 1.084 |
+| 128 | 512 | 1 | 93.16 | 30.23 | 1.086 |
+| 128 | 512 | 4 | 92.91 | 30.30 | 1.086 |
+| 512 | 64 | 1 | 92.68 | 30.28 | 1.086 |
+| 512 | 64 | 4 | 83.81 | 30.21 | 1.086 |
+| 512 | 256 | 1 | 80.10 | 30.31 | 1.086 |
+| 512 | 256 | 4 | 77.24 | 30.06 | 1.086 |
+| 512 | 512 | 1 | 66.28 | 29.92 | 1.086 |
+| 512 | 512 | 4 | 66.26 | 30.31 | 1.086 |
+
+The two sampling paths have different pre-v0.11 implementations. Greedy uses
+one padded batch but recomputes the full prefix at each step; seeded stochastic
+preserves per-request RNG by running the established sequential KV-cache path.
+These measurements are therefore separate baselines, not an algorithm ranking.
+
+## What remains unmeasured
+
+The legacy public backend does not expose clean prefill, decode or time-to-first
+token boundaries, so those fields are `not_measured`, not zero. Policy sync is
+`not_applicable` for an actor already loaded in the same process. Teacher
+scoring, actor update and full-cycle time are also `not_measured` in this
+rollout-only baseline and remain required before v0.11 release.
+
+`n=4` here is four independently repeated requests per prompt. Transactional
+group identity, grouped resume and reward composition do not exist in this
+baseline and cannot be inferred from it.
+
+## Artifact integrity
+
+| Artifact | SHA-256 |
+| --- | --- |
+| Preregistration | `8cc3ba738c69b59ed19c22c1de874fd00249404198a3e05983477dc8899bb7e5` |
+| Raw measurement | `2e303eabb559b843d25377a7c72e0aeb0219eec7eb8bc109c0419839b3251170` |
+| Final identity-bound result | `b25daee7ee726b7a7be18d7dbe26590fb61325bf212cfd9e7110b69f5fa8889c` |
+| Frozen calculator benchmark | `53fc1d4d5b7adee09618d77ad62d4086ba56b78569832d6fc7c3bcd5c2695bbc` |
+
+See the [method](rollout-runtime-v2-method.md) for timing and invalidation
+rules. The next backend must use this workload unchanged and pass the
+preregistered correctness, memory and 256/512-token speedup gates.
diff --git a/docs/release-checklist.md b/docs/release-checklist.md
index 6213883..9d0a5bd 100644
--- a/docs/release-checklist.md
+++ b/docs/release-checklist.md
@@ -10,7 +10,10 @@ after the exact release commit and its remote checks are green.
release and documentation remain at immutable `v0.10.1`.
- [x] Preregister the RTX 4080 Rollout Runtime v2 workload before measuring
the pre-v0.11 `hf_reference` baseline.
-- [ ] Freeze the `hf_reference` result before implementing `hf_cached`.
+- [x] Freeze the 24-cell `hf_reference` result from exact source commit
+ `0d6e0070ae73ef35f718aec3624ee5263ac96e3a` and candidate wheel
+ `0256bd9e63ca6ed52999a5073a3577a008581a8d4418062314750d86f21cd5fe`
+ before implementing `hf_cached`.
- [ ] Add typed policy identity, lifecycle and strict synchronization contracts.
- [ ] Qualify `hf_cached` at 64/256/512 response bounds and require at least 2x
speedup at 256 and 512 without exceeding 14.5 GiB peak reserved VRAM.
diff --git a/mkdocs.yml b/mkdocs.yml
index 6b9f7b6..67ac454 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -74,6 +74,7 @@ nav:
- Rollout Runtime v2:
- Competitive landscape: competitive-landscape.md
- Benchmark method: benchmarks/rollout-runtime-v2-method.md
+ - Frozen HF baseline: benchmarks/rollout-runtime-v2.md
- Maintainer:
- Architecture: maintainer-architecture.md
- Upstream support policy: upstream-support-policy.md
diff --git a/scripts/finalize_rollout_runtime_baseline.py b/scripts/finalize_rollout_runtime_baseline.py
new file mode 100644
index 0000000..08a37d9
--- /dev/null
+++ b/scripts/finalize_rollout_runtime_baseline.py
@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Bind immutable identity metadata to a completed rollout baseline.
+
+This finalization step never changes a measured cell. It preserves the raw
+measurement bytes, adds the exact base-weight digest and policy identity, then
+validates and atomically publishes the public result.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import jsonschema
+from huggingface_hub import snapshot_download
+
+from miniverl.utils.runs import canonical_json, write_json
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMA = ROOT / "benchmarks/schema/rollout-runtime-v2.schema.json"
+
+
+def _sha256_bytes(payload: bytes) -> str:
+ return hashlib.sha256(payload).hexdigest()
+
+
+def _weight_digest(model_id: str, revision: str) -> str:
+ snapshot = Path(
+ snapshot_download(
+ repo_id=model_id,
+ revision=revision,
+ allow_patterns=["*.safetensors"],
+ local_files_only=True,
+ )
+ )
+ weights = sorted(snapshot.rglob("*.safetensors"), key=lambda path: path.as_posix())
+ if not weights:
+ raise RuntimeError(f"cached snapshot {model_id}@{revision} has no safetensors weights")
+ digest = hashlib.sha256()
+ for path in weights:
+ relative = path.relative_to(snapshot).as_posix()
+ digest.update(relative.encode("utf-8"))
+ digest.update(b"\0")
+ with path.open("rb") as handle:
+ for block in iter(lambda: handle.read(1024 * 1024), b""):
+ digest.update(block)
+ return digest.hexdigest()
+
+
+def _driver_version() -> str:
+ return (
+ subprocess.check_output(
+ [
+ "nvidia-smi",
+ "--query-gpu=driver_version",
+ "--format=csv,noheader,nounits",
+ ],
+ text=True,
+ )
+ .splitlines()[0]
+ .strip()
+ )
+
+
+def _write_bytes_atomic(path: Path, payload: bytes) -> None:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ descriptor, temporary_name = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+ temporary = Path(temporary_name)
+ try:
+ with os.fdopen(descriptor, "wb") as handle:
+ handle.write(payload)
+ handle.flush()
+ os.fsync(handle.fileno())
+ temporary.replace(path)
+ finally:
+ temporary.unlink(missing_ok=True)
+
+
+def finalize(*, measured: Path, raw_output: Path, result_output: Path) -> dict[str, Any]:
+ raw = measured.read_bytes()
+ payload = json.loads(raw)
+ if payload.get("measurement_status") not in {"measured_baseline", "completed_with_failures"}:
+ raise RuntimeError("input is not a completed rollout baseline")
+ if "raw_measurement_sha256" in payload or "policy_identity" in payload:
+ raise RuntimeError("input already contains finalization metadata")
+ source_commit = payload.get("source", {}).get("commit")
+ if not isinstance(source_commit, str) or len(source_commit) != 40:
+ raise RuntimeError("raw measurement has no exact source commit")
+
+ actor = payload["models"]["actor"]
+ policy_identity = {
+ "policy_version": 0,
+ "profile_identity": "rollout-runtime-v2-hf-reference-baseline-v1",
+ "base_revision": actor["revision"],
+ "base_weight_digest_sha256": _weight_digest(actor["id"], actor["revision"]),
+ "adapter_digest_sha256": None,
+ }
+ policy_identity["identity_digest_sha256"] = hashlib.sha256(
+ canonical_json(policy_identity).encode("utf-8")
+ ).hexdigest()
+ payload["raw_measurement_sha256"] = _sha256_bytes(raw)
+ payload["policy_identity"] = policy_identity
+ payload["environment"]["driver_version"] = _driver_version()
+
+ schema = json.loads(SCHEMA.read_text(encoding="utf-8"))
+ jsonschema.validate(payload, schema)
+ result_output.parent.mkdir(parents=True, exist_ok=True)
+ _write_bytes_atomic(raw_output, raw)
+ write_json(result_output, payload)
+ return payload
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--measured", type=Path, required=True)
+ parser.add_argument("--raw-output", type=Path, required=True)
+ parser.add_argument("--result-output", type=Path, required=True)
+ args = parser.parse_args()
+ payload = finalize(
+ measured=args.measured.resolve(),
+ raw_output=args.raw_output.resolve(),
+ result_output=args.result_output.resolve(),
+ )
+ print(
+ json.dumps(
+ {
+ "status": payload["measurement_status"],
+ "raw_measurement_sha256": payload["raw_measurement_sha256"],
+ "policy_identity": payload["policy_identity"]["identity_digest_sha256"],
+ },
+ sort_keys=True,
+ )
+ )
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/tests/unit/test_packaging.py b/tests/unit/test_packaging.py
index b3a4c89..bf41dc8 100644
--- a/tests/unit/test_packaging.py
+++ b/tests/unit/test_packaging.py
@@ -298,6 +298,7 @@ def test_every_published_benchmark_result_validates_against_the_schema():
"alignment-lab-v1.json",
"alignment-lab-v1-state-supervision.json",
"alignment-external-v1.json",
+ "rollout-runtime-v2-hf-reference.json",
"rtx4080-verl-opd-runtime-v1.json",
"rtx4080-verl-opd-developer-v1.json",
"rtx4080-smollm2-opd-family-smoke-v1.json",
diff --git a/tests/unit/test_rollout_runtime_v2_benchmark.py b/tests/unit/test_rollout_runtime_v2_benchmark.py
index 83e72a1..1585c0f 100644
--- a/tests/unit/test_rollout_runtime_v2_benchmark.py
+++ b/tests/unit/test_rollout_runtime_v2_benchmark.py
@@ -40,6 +40,62 @@ def test_rollout_runtime_v2_preserves_frozen_calculator() -> None:
)
+def test_measured_hf_reference_baseline_is_exact_and_schema_valid() -> None:
+ expected = {
+ "benchmarks/preregistration/rollout-runtime-v2.yaml": (
+ "8cc3ba738c69b59ed19c22c1de874fd00249404198a3e05983477dc8899bb7e5"
+ ),
+ "benchmarks/evidence/rollout-runtime-v2/hf-reference-raw.json": (
+ "2e303eabb559b843d25377a7c72e0aeb0219eec7eb8bc109c0419839b3251170"
+ ),
+ "benchmarks/results/rollout-runtime-v2-hf-reference.json": (
+ "b25daee7ee726b7a7be18d7dbe26590fb61325bf212cfd9e7110b69f5fa8889c"
+ ),
+ }
+ for relative, digest in expected.items():
+ assert hashlib.sha256((ROOT / relative).read_bytes()).hexdigest() == digest
+
+ payload = json.loads(
+ (ROOT / "benchmarks/results/rollout-runtime-v2-hf-reference.json").read_text(
+ encoding="utf-8"
+ )
+ )
+ schema = json.loads(SCHEMA.read_text(encoding="utf-8"))
+ jsonschema.validate(payload, schema)
+ assert payload["measurement_status"] == "measured_baseline"
+ assert payload["failures"] == []
+ assert len(payload["cells"]) == 24
+ assert all(cell["status"] == "completed" for cell in payload["cells"])
+ assert payload["source"] == {
+ "commit": "0d6e0070ae73ef35f718aec3624ee5263ac96e3a",
+ "dirty": False,
+ "miniverl_version": "0.11.0.dev0",
+ "wheel_sha256": "0256bd9e63ca6ed52999a5073a3577a008581a8d4418062314750d86f21cd5fe",
+ }
+ assert payload["policy_identity"]["base_weight_digest_sha256"] == (
+ "b29cd98b83f9bddc7ec8943be5f142243e956f448f13456847849e5b8615b413"
+ )
+ assert max(cell["memory"]["peak_reserved_bytes"] for cell in payload["cells"]) == (1166016512)
+ raw_payload = json.loads(
+ (ROOT / "benchmarks/evidence/rollout-runtime-v2/hf-reference-raw.json").read_text(
+ encoding="utf-8"
+ )
+ )
+ measurement_view = dict(payload)
+ measurement_view.pop("raw_measurement_sha256")
+ measurement_view.pop("policy_identity")
+ measurement_view["environment"] = dict(measurement_view["environment"])
+ measurement_view["environment"].pop("driver_version")
+ assert measurement_view == raw_payload
+ for cell in payload["cells"]:
+ assert cell["counts"]["generated_tokens"] == (
+ 4 * cell["samples_per_prompt"] * cell["response_bound"]
+ )
+ for phase in ("prefill", "decode", "teacher_scoring", "actor_update", "full_cycle"):
+ assert cell["phases"][phase]["status"] == "not_measured"
+ assert "median_seconds" not in cell["phases"][phase]
+
+
def _phase(status: str, measured: bool = False) -> dict[str, object]:
payload: dict[str, object] = {"status": status}
if measured:
@@ -69,6 +125,7 @@ def test_rollout_runtime_v2_schema_keeps_unavailable_phases_distinct_from_zero()
"miniverl_version": "0.11.0.dev0",
"wheel_sha256": "b" * 64,
},
+ "raw_measurement_sha256": "9" * 64,
"preregistration_sha256": "c" * 64,
"workload_manifest_sha256": "d" * 64,
"frozen_calculator_sha256": (
@@ -94,6 +151,14 @@ def test_rollout_runtime_v2_schema_keeps_unavailable_phases_distinct_from_zero()
"version": "5.14.1",
"reproducibility_class": "same_process_seeded_reference",
},
+ "policy_identity": {
+ "policy_version": 0,
+ "profile_identity": "rollout-runtime-v2-hf-reference-baseline-v1",
+ "base_revision": "e" * 40,
+ "base_weight_digest_sha256": "8" * 64,
+ "adapter_digest_sha256": None,
+ "identity_digest_sha256": "7" * 64,
+ },
"cells": [
{
"cell_id": "p128-r64-n1-greedy",