README.md

---
pretty_name: RLVRAMBench — measured memory feasibility and configuration decisions
license: mit
language:
- en
tags:
- benchmark
- reinforcement-learning
- gpu-memory
- reproducibility
- resource-configuration
task_categories:
- other
configs:
- config_name: admission_candidates
  default: true
  data_files:
  - split: test
    path: benchmark/decision/results/candidate_results.csv
- config_name: transfer_configurations
  data_files:
  - split: measured
    path: benchmark/transfer_configurations.csv
- config_name: all_configurations
  data_files:
  - split: measured
    path: benchmark/configuration_results.csv
- config_name: eligible_runs
  data_files:
  - split: measured
    path: benchmark/runs.csv
- config_name: recorded_attempts
  data_files:
  - split: recorded
    path: benchmark/attempts.csv
- config_name: stage_measurements
  data_files:
  - split: measured
    path: benchmark/stage_measurements.csv
- config_name: transfer_queries
  data_files:
  - split: evaluation
    path: benchmark/queries.csv
- config_name: admission_attempts
  data_files:
  - split: recorded
    path: benchmark/decision/results/attempts.csv
- config_name: larger_model_configurations
  data_files:
  - split: measured
    path: benchmark/estimation/results/configurations_flat.csv
- config_name: expanded_host_configurations
  data_files:
  - split: measured
    path: benchmark/host_capacity/results/configurations_flat.csv
- config_name: configuration_feasibility
  data_files:
  - split: configurations
    path: tables/three-model-configurations.csv
---

# RLVRAMBench

**Which language-model training configurations can I use with the memory
I have, and how much testing does that decision require?**

RLVRAMBench is a measurement dataset with open evaluation tasks for a
specific language-model training system. It measures memory feasibility
when response generation and reinforcement-learning updates share the
same graphics processors. It provides measured outcomes, fixed prediction
tasks, a budgeted decision replay, reference methods, and raw failure evidence.
It does **not** score a model's intelligence or learning quality.
The companion article is **Memory Feasibility in Colocated Language-Model
Reinforcement Learning: A Failure-Aware Measurement Study**. This is a
focused, extensible study, not a comprehensive cross-platform benchmark
or evidence of community adoption.

The default table above is a readable twelve-candidate experiment. Each
row shows the model, workload, hardware, training settings, earlier source
label, new screening outcome, and a repeated evaluation outcome obtained
from **different random seeds**. The other views expose the broader
measurement corpus and transfer tasks.

Authors: Ondřej Kobza and Jan Šedivý, Czech Institute of Informatics,
Robotics and Cybernetics, Czech Technical University in Prague.
ORCID: [Kobza](https://orcid.org/0000-0002-0529-9860),
[Šedivý](https://orcid.org/0000-0003-0626-2303).

- [Paper PDF](paper/RLVRAMBench_IEEE_Access_submission.pdf)
- [Supplement](paper/RLVRAMBench_supplement.pdf)
- [Public reproduction code](https://github.com/kobzaond/RLVRAMBench-reproduce)
- [Benchmark instructions](BENCHMARK.md)
- [Data dictionary](DATA_DICTIONARY.md)
- [Pinned release and archive](release.json)

## What is measured?

Each process either completes its requested training and scheduled
operations, has a diagnosed memory failure, or remains unresolved for
resource-label purposes. External device-memory samples measure the
maximum used memory on **any one allocated device**, not a sum across GPUs.

For the three distinct eligible evaluation seeds of a configuration:

| Outcome | Meaning |
|---|---|
| `within_margin` | All three complete and each peak is at most 38,912 MiB |
| `above_margin` | All three complete, but at least one exceeds that limit |
| `memory_failure` | At least one eligible run has a diagnosed memory failure |

The limit leaves 5% below the measured capacity of 40,960 MiB per device.
It is a stated operating convention, **not a statistical guarantee**.
One mebibyte (MiB) is 1,048,576 bytes. Failed runs do not have a
counterfactual completed-run peak; blank completed-peak fields are not zero.
All three slots must have eligible outcomes before the repeated label
is assigned, even if a partial record already contains a diagnosed
failure. Unresolved attempts and known partial failure evidence remain visible.

These are conditional memory outcomes. They do not say that every
scheduler job, software invocation, or future repetition will complete.
The full attempt history is therefore separate from eligible labels.

## Ways to use the measurements

### 1. Predict a target outcome from existing measurements

A method receives explicit source measurements and target settings, but
not target outcomes. It predicts one of the three labels. For example,
can a configuration measured on four GPUs run on two?

The static suite contains 52 tasks and 400 queries across model, workload,
GPU-count, and run-duration transfer. Queries reuse **94 distinct target
configurations**. They are not 400 independent experiments.
Source-copy, always-approve and always-reject results are provided.

Use the public code repository:

```bash
python3 benchmark.py verify
python3 benchmark.py baseline --rule source_label --output predictions.csv
python3 benchmark.py evaluate --predictions predictions.csv --output scores.json
```

For another method, export allowed evidence with `benchmark.py inputs`,
then provide a CSV with `query_id,predicted_state`. The evaluator rejects
missing, duplicate, extra or invalid predictions. Reading the public
target tables while producing predictions violates this task contract.

### 2. Decide which candidates to admit as tests become available

The admission panel asks whether available source evidence helps identify
usable target configurations before all of them have been tested.
It contains four model–workload cases, three candidate settings per case,
and 48 fresh processes:

- One five-step screen per candidate can be requested by a rule.
- Three separate five-step evaluation seeds determine the target label.
- Screening outcomes never contribute to that evaluation label.

Source copy initially approves the donor's within-margin settings.
A headroom guard also requires an additional source-memory allowance.
Direct screening starts without approving any candidate and uses no donors.
All request screens in the same frozen order. Each invocation is charged
before its outcome is revealed; unrequested target results remain hidden
from the replay.

```bash
python3 decision_benchmark.py replay \
  --protocol benchmark/decision/protocol.json \
  --attempts benchmark/decision/results/attempts.json \
  --output admission-scores.json
```

`scores.json` includes each case, each budget, requested attempts, revealed
screens and resulting decisions. `summary.csv` is the compact comparison.
The protocol and prelaunch amendment are retained with their timestamps.
No memory failure is retried to obtain a favorable outcome. Unresolved
evaluation slots retain admissible-outcome bounds.

### Observed admission results

All 48 planned processes supply validated memory outcomes, with no
retries or unresolved slots. The twelve evaluation candidates contain
six within-margin configurations, two above-margin configurations, and
four memory failures. Screens and separate evaluation repetitions agree
in this panel.

| Rule | Case-averaged recall before testing | First tested common per-case budget with full recall | Prior donor attempts across four cases | Memory-failure / above-margin approvals |
|---|---:|---:|---:|---:|
| Copy the source label | 100% | 0 | 36 | 0 / 0 |
| Additional headroom guard | 75% | 1 | 36 | 0 / 0 |
| Direct screening | 0% | 3 | 0 | 0 / 0 |

Direct screening reaches 25%, 75%, and 100% case-averaged recall at
budgets of one, two, and three attempts per case. Case averaging gives
each model–workload combination equal weight, rather than pooling
candidates. The guard initially rejects two usable Qwen candidates.
Source copy and the guard differ only at those candidates, which are
queried first; their positive-budget decisions are **identical by
construction**, not two independent confirmations.

This is evidence that the specified existing measurements were sufficient
for this selected workload change, not a universal transfer result.
The separate GPU-transfer task below contains harmful approvals.
The first common budget attaining full recall is not a proof of the
minimum number of tests an optimized strategy would require.
Without an existing donor profile, the attributed counts for full recovery
are 36, 40, and 12 attempts respectively, with different work per attempt.
Thus the comparison does not establish cold-start or GPU-time superiority
of transfer. All three rules have 100% observed precision wherever they
approve anything; the small panel does not estimate future failure risk.

### 3. Compare estimators with complete model families held out

The separate `benchmark/estimation/` comparison asks whether architecture
and configuration information improves on copying an earlier outcome.
It uses ninety historical configurations. Each of three tests withholds
all thirty configurations of one model family and fits on the other sixty.
Seeds and alternative GPU counts of the test family are not fitting examples.

References include donor copying, empirical component regression with a
one-sided startup check, and regularized logistic classification.
The regression uses completed peaks without inventing numerical targets
for failures; the classifier also learns from failure labels.
These are not exact tensor-liveness models or calibrated failure probabilities.

Results differ by family: regression gets every Qwen label right but
approves four memory-failing Granite configurations; the classifier rejects
six usable Qwen settings. Read the separate approval errors, not just
accuracy. The historical labels were public during design, so this is
not blind method development.

The [estimator guide](benchmark/estimation/README.md) explains inputs,
frozen predictions, acquisition costs and CPU reconstruction.

### 4. Inspect prospective larger-model transfer

The `larger_model_configurations` view contains twelve planned Qwen2.5-7B
settings with predictions frozen before target execution. Each row shows
how many of its three seed outcomes are eligible, any known partial failure
evidence, the resolved label when available, and each method's prediction.
This is size transfer within a familiar model family, not a new-family test.

The original panel has 23 eligible startup memory-admission failures and
13 unresolved slots, with no completed training steps. Only six repeated
labels resolve, all to failure. Donor copying wrongly approves those six;
the fitted references reject them, but an always-failure rule does too.
Their scores on this subset do not demonstrate recovery of usable settings.
In particular, the regression's three approvals have unresolved outcomes.

The `expanded_host_configurations` view is a separate follow-up to
host-memory exhaustion in the original panel. It retains the frozen
predictions, uses new seed slots, and increases the host-resource
allocation. Its six settings are not replacements for original targets.
All nine two-GPU invocations fail the startup memory check. The nine
four-GPU invocations exit successfully but lack the required final-step
record, leaving their three repeated labels unresolved. No validated
completion is available in this panel either. See the
[follow-up guide](benchmark/host_capacity/README.md) for the diagnostic
evidence and separate allocation costs.

## What score should I report?

Report **within-margin recall at a stated measurement budget**, together
with separate memory-failure and above-margin approvals.

- **Recall:** what fraction of the genuinely within-margin candidates did
  the rule approve?
- **Approval precision:** what fraction of its approvals were within margin?
- **Approval errors:** how many approvals actually fail for memory, and
  how many complete but exceed the chosen limit?
- **Effort:** how many target attempts were requested? Was source evidence
  already available or did it have to be collected?

A zero denominator is `null`, not a perfect score. Approving nothing
avoids approval errors but recovers nothing; approving everything recovers
every usable candidate but may also admit failures. Neither should win by
hiding the other side of that trade-off.

There is intentionally no unexplained scalar combining errors and cost.
Those trade-offs depend on the user's application. Label accuracy is
provided for diagnosis, not as a universal deployment ranking.

An exact example from GPU-count transfer shows why this matters:

| Reference rule | Correct labels / 36 queries | Within-margin targets approved | Memory failures approved | Above-margin targets approved |
|---|---:|---:|---:|---:|
| Copy the source label | 20 | 20 | 2 | 4 |
| Approve everything | 26 | 26 | 4 | 6 |
| Reject everything as a memory failure | 4 | 0 | 0 | 0 |

“Approve everything” has higher label accuracy than copying, but admits
twice as many memory failures. Pooled accuracy also overweights easy tasks:
216 of the 400 queries are workload transfers solved by lookup on this
grid. The four duration queries offer little discrimination.
Always retain the per-track and per-case results.

## What does this release contain?

The static tables contain 212 settings, 612 eligible processes, 683
recorded attempts and 3,434 observed stage measurements. These include
the original 588-process corpus and 24 completed batch-by-logging controls.
Sixteen historical source screens are counted separately in the archive.
The 48-slot admission panel is separate; it is not silently added to
the unchanged static-table totals.
The estimator comparison reuses ninety of those historical configurations;
its three test folds are not additional GPU experiments.
The original larger-model panel and expanded-host follow-up have their own
configuration and process tables. Their planned slots, unresolved outcomes,
and costs are not included in the static or admission totals above.

The default candidate table is a useful entry point. `configurations.csv`
contains settings without outcomes. `configuration_results.csv` and
`transfer_configurations.csv` join them for browsing. `runs.csv`,
`attempts.csv`, and `stage_measurements.csv` preserve process, invocation,
and execution-stage detail. They have different units and must not be
concatenated into one dataset of independent examples.

The compressed review archive contains raw training logs, external
memory traces, allocator records, environment provenance, frozen matrices,
attempt exclusions, and reconstruction code. Model weights and optimizer
checkpoint payloads are **not** redistributed.

## Cost accounting

For static prediction, source-cost fields count **supplied evidence**;
they are not measured acquisition effort by a method.

For admission replay, three ledgers remain separate:

1. The donor evidence already available to transfer-informed rules.
2. The target attempts actually requested at each budget.
3. All physical runs collected to evaluate the rules, including hidden
   evaluation seeds.

Cold-start accounting charges the donor investment as well. It does not
make those measurements free or establish superiority over a direct
strategy allowed an equally large budget of extra target repetitions.
One donor step and five target steps also have different runtime costs.
Recorded GPU-seconds exclude queue time and other allocation overhead.

## Scope and appropriate reuse

The experiments use compact language models with low-rank adaptation and
Group Relative Policy Optimization, in a fixed VERL/vLLM execution stack.
Generation and training share NVIDIA A100 devices. They ran on
[Karolina](https://www.it4i.cz/en/infrastructure/karolina), a supercomputer
at IT4Innovations in Ostrava, Czech Republic.

Use the records to evaluate resource-label prediction, compare measured
admission decisions, audit failures, study why stage and overall peaks
differ, or reconstruct the paper. Do not use them to claim a general
failure probability, convergence benefit, safe full training schedule,
or transfer to unmeasured hardware and model scales.

The cases were selected, not randomly sampled. New admission outcomes
come from familiar model/workload families; their four cases are not
48 independent cases. The public labels make inspection possible but
also mean this is not a permanently hidden test set. Strong claims about
a new predictor need genuinely unseen cases beyond this release.

Some historical executions used modified source working trees without
captured per-run patches. Their commit IDs do not by themselves reconstruct
those modifications. Later controls and the admission panel use immutable
source copies. Rebuilding results from saved traces is distinct from
recreating every historical GPU execution.

## Reproduce and cite

The code repository pins an immutable evidence archive and verifies its
SHA-256 digest and extracted file manifest. CPU-only reconstruction
regenerates results from raw evidence before comparing them with the
published tables. Optional filesystem isolation hides those reference
tables and the original project during analysis.

GPU reruns are a separate, more demanding task: obtain upstream models
under their terms and adapt the recorded environment and cluster-specific
launchers. Keep all virtual environments inside their project directory.

Original benchmark measurements and reproduction software are MIT
licensed. Third-party data, model, software and template terms remain
separate; see [RIGHTS.md](RIGHTS.md). The archive is not a relicensing
of upstream material. Both benchmark and code repositories are public
and ungated. No DOI is claimed until the authors create one.