paper/RLVRAMBench_IEEE_Access_submission.tex

% Authoritative submission manuscript. Edit this TeX directly; do not overwrite
% it by regenerating from the earlier Markdown preparation sources.
\documentclass{ieeeaccess}
\usepackage{cite}
\usepackage{amsmath,amssymb,amsfonts}
\usepackage{graphicx,textcomp,booktabs,array,calc}
\usepackage[T1]{fontenc}
\usepackage{iftex}
\ifPDFTeX
  \DeclareUnicodeCharacter{2192}{\ensuremath{\rightarrow}}
  \DeclareUnicodeCharacter{2212}{\ensuremath{-}}
\fi
\usepackage{xurl}
\usepackage[hidelinks]{hyperref}
\usepackage{fvextra}
\usepackage{placeins}
\usepackage{etoolbox}
\usepackage[expansion=false]{microtype}
\DefineVerbatimEnvironment{verbatim}{Verbatim}{breaklines=true,breakanywhere=true,fontsize=\footnotesize}
\providecommand{\tightlist}{\setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
\newcommand{\passthrough}[1]{#1}
\makeatletter
\newsavebox\pandoc@box
\newcommand*\pandocbounded[1]{\sbox\pandoc@box{#1}%
  \ifdim\wd\pandoc@box>\linewidth\resizebox{\linewidth}{!}{\usebox\pandoc@box}%
  \else\usebox\pandoc@box\fi}
% Publication volume/year/DOI are assigned by the publisher.
% Suppress the unassigned fields without changing vendor class files.
\patchcmd{\@maketitle}
  {{\vss\doifont Digital Object Identifier\space\@doi\vss}\vspace*{7.4mm}\par}
  {}{}{\PackageError{rlvrambench}{Cannot suppress the publisher DOI field}{}}
\patchcmd{\thebibliography}
  {\section*{\refname}}{\section*{\refname}\phantomsection}
  {}{\PackageError{rlvrambench}{Cannot set the bibliography navigation anchor}{}}
% Keep the two short biographies compact; the vendor class remains unchanged.
\patchcmd{\IEEEbiographynophoto}
  {\vskip 4\baselineskip plus 1fil minus 0\baselineskip}
  {\vskip 1.5\baselineskip}
  {}{\PackageError{rlvrambench}{Cannot set local biography spacing}{}}
\def\rlvramfooter{\hbox to\textwidth{%
  {\footervolfont RLVRAMBench}\hfill%
  {\footerpagefont\thepage}}}
\let\rlvramoriginalheadings\ps@headings
\def\ps@headings{\rlvramoriginalheadings
  \let\@oddfoot\rlvramfooter\let\@evenfoot\rlvramfooter}
\let\rlvramoriginaltitlepage\ps@titlepage
\def\ps@titlepage{\rlvramoriginaltitlepage
  \let\@oddfoot\rlvramfooter\let\@evenfoot\rlvramfooter}
\makeatother
\pagestyle{headings}
\ifXeTeX
  \special{pdf:mapfile t1-times.map}
  \special{pdf:mapfile t1-formata.map}
  \special{pdf:mapfile t1-giovannistd.map}
\fi
\setlength{\emergencystretch}{1em}
\begin{document}
\history{}
\doi{}
\hypersetup{pdftitle={Memory Feasibility in Colocated Language-Model Reinforcement Learning: A Failure-Aware Measurement Study},pdfauthor={Ond\v{r}ej Kobza, Jan \v{S}ediv\'{y}}}
\title{Memory Feasibility in Colocated\\
Language-Model Reinforcement Learning:\\
A Failure-Aware Measurement Study}
\author{\uppercase{Ond\v{r}ej Kobza}\authorrefmark{1}, AND \uppercase{Jan \v{S}ediv\'{y}}\authorrefmark{1}}
\address[1]{Czech Institute of Informatics, Robotics and Cybernetics, Czech Technical University in Prague, Jugosl\'{a}vsk\'{y}ch partyz\'{a}n\r{u} 1580/3, 160 00 Prague 6, Czech Republic}
\tfootnote{ORCID: Ond\v{r}ej Kobza: \href{https://orcid.org/0000-0002-0529-9860}{0000-0002-0529-9860}; Jan \v{S}ediv\'{y}: \href{https://orcid.org/0000-0003-0626-2303}{0000-0003-0626-2303}}
\markboth{Kobza and \v{S}ediv\'{y}: RLVRAMBench}{Kobza and \v{S}ediv\'{y}: RLVRAMBench}
\begin{abstract}
Colocating language-model generation and training places different memory
demands on the same graphics processors. We present a failure-aware
measurement study of low-rank adaptation with Group Relative Policy
Optimization in a fixed training-and-generation implementation on A100 hardware.
The study distinguishes completion within a chosen memory margin,
completion above it, and memory failure. Releasing generation state
allowed several tested configurations to complete when retaining it did
not. Same-device controls found larger training-stage peaks with larger
per-device training batches, while the overall peak changed little; logging affected
the measured magnitude. Individual short tests missed some later margin
crossings, whereas the labels combining repeated tests agreed.
Earlier labels agreed in a small workload-screening panel, but copying
across GPU counts or to a larger model admitted failures.
In held-out-family comparisons, neither empirical
memory regression nor a learned classifier uniformly improved on copying
earlier labels. The released
dataset, RLVRAMBench, links outcomes to execution stages, retains failed
and incomplete attempts, and supports reconstruction and comparison of
configuration decisions.
\end{abstract}
\begin{keywords}
colocated execution, failure analysis, GPU memory, Group Relative Policy Optimization, measurement study, reproducibility
\end{keywords}
\titlepgskip=-21pt
\maketitle
\section{Introduction}\label{introduction}

Reinforcement learning for language models alternates between generating
responses, called \emph{rollouts}, and updating the \emph{policy}, or actor,
that generated them. Rewards evaluate the answers. In the setup studied
here, a fixed reference
policy supplies response probabilities used to penalize departure from
the initial policy. Weight synchronization copies updated weights to the
generation engine. \emph{Colocated execution} assigns generation and
training to the same graphics processing units (GPUs).

Memory demand changes between these stages. State retained by the
generation engine can remain present during training or weight transfer,
so a configuration that completes generation may fail later. A useful
measurement must therefore record out-of-memory (OOM) failures as well
as successful-run peaks. We study \emph{memory feasibility}: completion
of the requested work, with a separate label for completion that leaves
a specified memory margin. The objective is resource feasibility, not
model quality or training speed.

The study uses synchronous Group Relative Policy Optimization (GRPO)
with low-rank adaptation (LoRA) in VERL, a language-model reinforcement
learning framework, and its vLLM generation engine. GRPO learns from the
relative rewards of responses to the same prompt; LoRA trains small
adapter matrices while keeping the base weights fixed. We examine
configuration choices within this implementation on A100 GPUs.

The intended user is a researcher adapting an earlier configuration:
for example, moving a setting measured on four GPUs to two. Earlier
measurements may guide this decision, but a target execution is needed
to check whether their labels transfer. A \emph{screen} is a short
execution test of a candidate. Our comparisons examine what existing
measurements, fixed predictors, and additional screens establish.
We count within-margin candidates recovered, failing or above-margin
candidates approved, and the execution evidence required for each
decision. Three investigations support this comparison:

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\tightlist
\item
  \textbf{Failure-inclusive configuration outcomes.} A selected
  model--workload grid distinguishes within-margin completion,
  above-margin completion, and memory failure.
\item
  \textbf{Tests of what memory summaries omit.} Paired state-release
  comparisons and measurement controls expose completion changes and
  training-stage growth hidden by whole-run peaks.
\item
  \textbf{Limits of reuse and short testing.} Transfer comparisons,
  fitted prediction baselines, a prospective decision case study, and
  paired short/long executions measure agreement and decision errors
  under changed settings and schedules.
\end{enumerate}

RLVRAMBench releases the measurements, attempt inventory, and
evaluation software supporting these investigations.

\subsection{Research questions}\label{research-questions}

The study addresses three research questions (RQs):

\begin{itemize}
\tightlist
\item
  \textbf{RQ1 --- Outcomes and transfer:} Which tested settings complete
  within margin, and how well do reused labels and fixed predictors
  identify them when the setting changes?
\item
  \textbf{RQ2 --- Stage measurements:} What do state-release and
  batching comparisons reveal beyond the whole-run peak?
\item
  \textbf{RQ3 --- Execution schedule:} How do labels from short and
  longer executions agree when validation and checkpoint writing are included?
\end{itemize}

\section{Related work}\label{related-work}

\subsection{Execution and memory management}\label{execution-and-resource-sharing-in-language-model-training}
\label{memory-management-during-generation-and-training}

Systems for reinforcement learning from human feedback (RLHF) coordinate
generation, scoring, and updates through different placements of model
state. DeepSpeed-Chat combines training and inference optimizations
\cite{yao2023deepspeedchat}; HybridFlow redistributes actor state between
these stages \cite{sheng2024hybridflow}; and RLHFuse combines work within
and across stages \cite{zhong2024rlhfuse}. ReaL searches parameter
reallocation plans \cite{mei2024realhf}. These systems change execution
to improve efficiency, whereas our study measures configuration outcomes
within one execution design.

Memory management also changes what remains resident between stages.
vLLM stores cached attention state from earlier tokens in blocks
\cite{kwon2023pagedattention} and provides Sleep Mode to move weights
to host memory or discard cached state
\cite{vllm2026sleepmode}. Hydra-RLHF shares base weights across selectable
adapters to reduce policy-training memory \cite{santacroce2023hydra}.

Zhou et al.\ study memory use in DeepSpeed-Chat and ColossalChat, including
LoRA, retained state, and release of unused cache from the framework's
memory manager, or \emph{allocator}
\cite{zhou2024rlhfmemory}. They show that a training-memory control can
leave the overall peak unchanged when inference sets that peak.
Our contribution builds on this observation: failure-inclusive GRPO
outcomes, paired generation-state release, stage-measurement controls,
and tests of label agreement across settings and schedules. The vLLM
weight offload and cache discard studied here is a different intervention
from releasing unused PyTorch allocator cache.

\subsection{Memory estimation and configuration decisions}\label{failure-aware-configuration-measurement}

Analytical estimators predict memory before training. DNNMem accounts
for the computation graph and framework runtime, motivated in part by
jobs that fail for lack of GPU memory \cite{gao2020dnnmem}. LLMem uses
decoder-model structure and the memory distribution of distributed
fine-tuning methods to estimate their peaks and compare configurations
\cite{kim2024llmem}. For RLHF, ReaL combines static memory---gradients
and optimizer state---with active memory, including attention caches,
intermediate layer outputs (activations), and parameters moved between
roles. It estimates each function call
and takes the maximum over the iteration and devices to assess a plan's
feasibility \cite{mei2024realhf}. Component accounting and the stage-wise
maximum thus have direct precedents. These estimators use model and
execution information; label transfer instead reuses measured outcomes
from a specified source setting.

SLO-Guard includes crashes when tuning standalone vLLM serving under
service-level objectives, such as response-time targets
\cite{lysenstoen2026sloguard}. Here, failures may arise during generation,
updates, or weight transfer. We compare fixed rules for approving
configurations, including empirical memory regression and a learned
classifier, and preserve failed attempts alongside completed peaks.
The measured objective is completion and margin compliance, rather than
service latency or an optimized search strategy.
A direct comparison with the established memory estimators would require
implementing and validating their execution and profiling assumptions
for this stack. Here we compare fixed empirical baselines fitted from
the released configuration records; this does not test the accuracy
of DNNMem, LLMem, or ReaL.

\section{Study setting and measurements}\label{rlvrambench}

This section defines the execution, outcome labels, and comparisons
recorded in RLVRAMBench. Most experiments use two A100 GPUs with 40 GB
of memory; a four-GPU study tests transfer between allocation sizes.

\subsection{Execution and batching}\label{cases-and-configurations}

A training iteration starts with a batch of prompts. The generation
workers produce several responses to each prompt; reward functions evaluate
those responses, and policy and reference calculations provide the
probabilities needed for the update. The actor then updates its adapters,
and weight synchronization makes the updated policy available for the
next generation period. Scheduled validation generates answers without
training, while checkpoint writing saves the training state.

The \emph{global batch} counts prompts, not generated responses. For
example, the Grade School Math 8K (GSM8K) workload \cite{cobbe2021gsm8k}
uses 32 prompts and generates two
responses per prompt, supplying 64 prompt--response sequences for the
update. The actor \emph{micro-batch} specifies how many such sequences
one GPU processes at once. Smaller micro-batches accumulate the update
over more pieces without changing that global batch. Separate
micro-batches govern policy and reference log-probability calculations.

In this LoRA implementation, reference scoring reuses the actor's frozen
base model with its adapters disabled; it does not allocate a separate
reference-model copy. Rule-based reward functions run on the host
processors. No learned reward model or \emph{critic}, a model estimating
expected returns, occupies GPU memory. The principal device-resident
components are therefore training state divided across GPUs and the generation
workers, whose state can remain present between generation periods.

\subsection{Cases and configuration controls}\label{configuration-factors}

Models process text as \emph{tokens}, the units produced by a tokenizer.
During generation, a key--value (KV) cache stores attention results for
previous tokens.

A \emph{workload} specifies the task data, prompt and response length
limits, responses per prompt, and global batch. A \emph{case} combines
that workload with a model, GPU count, and requested execution duration
and operation schedule. A \emph{configuration} selects the memory and
micro-batching controls within that case. This hierarchy keeps a new
random seed distinct from a new workload or execution setting.

The vLLM reservation is the requested fraction of device memory assigned to
the generation engine. Length limits and the maximum number of active
sequences further constrain its work. \emph{Offloading} moves state to
host memory. Actor parameter and optimizer offload are separate controls
from generation-state release: the latter suspends the generation workers,
offloads their weights, and discards their attention cache between
generation periods. Resident mode keeps that generation state on the
devices. Section~\ref{experimental-protocol} specifies the tested settings
and restoration behavior.

\subsection{Three-state labels}\label{safety-labels-and-units-of-analysis}

Each planned \emph{slot} specifies a configuration and random seed, with
a fresh process for each repetition. A complete configuration label
requires eligible memory outcomes for all three slots. An eligible
outcome either completes the requested work or has a diagnosed GPU-memory
failure. This includes the generation engine rejecting its requested
device-memory budget, not only an allocation failure. Host-memory exhaustion
and other unresolved execution failures do not supply GPU-memory labels.
We use the shorter term \emph{memory failure} for this GPU-specific class.

Memory is reported in mebibytes (MiB, \(2^{20}\) bytes) and gibibytes
(GiB, \(2^{30}\) bytes). The operating limit is 38,912 MiB, leaving
2,048 MiB below each device's reported capacity. This margin was chosen
before the experiments as a convention, not an estimate of the physical
failure point. The three configuration labels are:
\begin{itemize}
\item \emph{Within-margin completion}: all three repetitions complete
      and no sampled per-GPU peak exceeds the operating limit.
\item \emph{Above-margin completion}: all three complete, but at least
      one peak exceeds the limit.
\item \emph{Memory failure}: at least one eligible repetition has a
      diagnosed memory failure.
\end{itemize}
A missing eligible slot leaves the repeated label unresolved.
For label predictors, only a within-margin prediction counts as approval.
An approval error admits an above-margin or memory-failing configuration; these two
errors are counted separately. The artifact's shorthand \emph{safe}
denotes within-margin completion only.

Peak memory takes the maximum over sampled times, GPUs, and repetitions;
runtime averages completed repetitions. The highest observed within-margin
configuration level summarizes the tested boundary, without assuming
the same outcome for untested settings. Levels are test indices, not rankings
of throughput or training quality.

\subsection{Configuration comparisons}\label{benchmark-tasks-and-evaluation}

A task supplies the target configuration's settings and measurements
from a specified source case, or \emph{donor}. The method predicts the
target's three-state label; target measurements are reserved for scoring.
The source-label baseline copies the matched donor configuration's outcome.
Comparisons change model, workload, GPU count, or execution horizon while
holding the other specified settings fixed. Whole cases remain separate:
another target seed or a supporting target control is not permitted donor
evidence.

Scoring reports three-state accuracy together with within-margin
\emph{recall}, the fraction of within-margin targets approved, and
\emph{precision}, the fraction of approvals that are within margin.
Counts of memory-failure approvals, margin-violating approvals, and
rejected within-margin settings accompany these rates. An empty
denominator is undefined.

The budgeted comparison also permits requested target screens.
A rule approves, rejects, or abstains; abstention withholds approval
without asserting failure. Separate repetitions evaluate its decisions
(Section~\ref{prospective-admission}).

The released tasks reuse targets and expose their labels publicly.
They are inspectable comparisons, not independent experiments or a hidden
test set. Supplementary Section S13 specifies the task inventory and
input-separation contract.

\subsection{Measurements}\label{measurements}

Each invocation records the configuration, random seed, software environment, elapsed time, exit status, and any failure. Experiment identifiers link these records to jobs submitted through Slurm, the cluster's job scheduler.

External sampling uses the NVIDIA Management Library (NVML), which exposes
device-level memory use and utilization, at 100 ms intervals. Host-side
markers identify the execution stages described above, including
initialization and scheduled validation and checkpoint writing. Samples
receive the current marker. Markers do not synchronize the GPUs:
stage attribution follows the observed execution interval, not the
lifetime of each allocation. Unmarked intervals remain idle or unknown.

Allocator traces record PyTorch tensor allocations and retained memory.
Allocated tensor memory is not the same quantity as total device memory.
A stage peak restricts the external maximum to that stage's marked
interval. Whole-run peak comparisons use completed runs: a failed run's
partial maximum is not its completed-run peak. A stage contrast can
include a later-failing run only when the compared stage finishes in both
conditions. Interrupted or absent stages remain missing, not zero.

\subsection{Workloads and preparation}\label{workload-strata}

GSM8K contains mathematical word problems; MATH contains competition
mathematics problems \cite{hendrycks2021math}; and CodeContests contains
programming problems \cite{li2022alphacode}. Their length limits and
responses per prompt define the requested work, not the lengths of every
sequence actually generated.

The \emph{standard code} and \emph{longer-prompt code} subsets select
opposite ends of the same CodeContests prompt-length ordering; they are
not independent corpora. Preparation uses Qwen tokenizers, whereas each
run filters prompts using its selected model's tokenizer. Thus, a matched
workload need not supply identical token sequences or examples across
models. Supplementary Section S12 gives the selection recipe, filtering
counts, and realized lengths.

For GSM8K, the reward extracts a formatted final answer and compares it
with the recorded answer. For MATH, it extracts the final boxed expression
and compares normalized answer strings. For code, the reward checks
Python syntax and the presence of input/output operations without
executing the generated program or using the CodeContests correctness
tests. These functions provide the rewards needed to execute GRPO;
we do not evaluate their effect on answer quality.

\subsection{Failures, eligibility, and attempts}\label{failure-taxonomy}
\label{artifact-validity-and-retry-policy}

An \emph{attempt} is an invocation of a slot's runner, not merely a queued
job. We distinguish setup errors, diagnosed memory failures, and other
or unresolved noncompletion. Failure stages follow the logs and traces;
an allocator error alone does not show that free memory split into
unusable pieces, or \emph{fragmentation}, caused the failure.

Eligibility requires a trial record, environment record, execution log,
stage trace, and per-GPU measurements. Completion additionally requires
a successful exit and evidence of the requested final work. A nonzero
exit enters the memory analysis only with diagnosed memory failure.
Other attempts retain their status and exclusion reason. Early failures
and external-only controls can lack allocator traces; their remaining
evidence determines eligibility.

Historical repairs repeated unchanged scientific settings after setup
errors or some later noncompletions. Exactly one eligible outcome is
selected per slot after documented exclusions; earlier attempts remain
in the ledger. Repeated seeds are separate slots, not retries. The
result sections report relevant attempt denominators, and Supplementary
Section S1 records the repair histories, including an incomplete
memory-failure record. The labels are conditional memory outcomes,
not estimates of all-cause job completion.

\subsection{Experiment planning and selection}\label{experiment-planning-and-selection}

Pilots developed the ranges and instrumentation; subsequent matrices
fixed settings and seeds before execution. Restriction to standard GRPO
followed exploratory outcomes with a custom objective. Those observations
and pilots remain archived but do not enter the reported estimates.
The original transfer baselines, stage reanalysis, and margin and
attempt audits are retrospective. Later controls were specified before
their own execution using earlier results to select cases. Supplementary
Section S1 records this sequence and its amendments.

\section{Experimental protocol}\label{experimental-protocol}

Table~\ref{tab:design} links the questions to their comparisons.
Measurement controls support interpretation of the traces; they are
not additional target evidence available to prediction methods.

\begin{table*}[!t]
\centering
\caption{How the experiments support the research questions.}\label{tab:design}
\small
\setlength{\tabcolsep}{4pt}
\begin{tabular}{@{}p{0.12\linewidth}p{0.23\linewidth}p{0.29\linewidth}p{0.29\linewidth}@{}}
\toprule
Question & Comparison & What changes & Primary evidence \\
\midrule
RQ1 & Boundary and transfer & Model, workload, or GPU count & Repeated three-state labels and directional approval errors \\
RQ1 & Estimation and matched GPU count & Held-out model family, then a larger model on matched allocations & Frozen predictions, approval errors, and paired outcomes \\
RQ1 & Budgeted admission & Available donor evidence and target-screen budget & Within-margin recall and approval errors on separate evaluation seeds \\
RQ2 & State release & Generation state released or resident on the same GPUs & Paired completion and completed-run peaks \\
RQ2 & Batch and reservation & Actor micro-batch and generation reservation & Whole-run versus actor-stage contrasts \\
Measurement & Sampling and allocator logging & Sampling interval or logging condition & Label agreement, peak differences, and incomplete attempts \\
RQ3 & Short and longer execution & Requested steps and scheduled operations & Individual and repeated label agreement; later peak growth \\
\bottomrule
\end{tabular}
\end{table*}

\subsection{Hardware and software}\label{hardware-and-software}

The experiments ran on Karolina, a supercomputer operated by IT4Innovations National Supercomputing Center in Ostrava, Czech Republic \cite{it4i2026karolina}. Its accelerated nodes contain eight NVIDIA A100 GPUs; our jobs used allocations of two or four A100-SXM4-40GB devices. Each device reported 40,960 MiB of memory, with driver version 610.43.02.

The container used Python 3.12.3, PyTorch 2.10.0, NVIDIA's CUDA execution
platform 12.9, and vLLM 0.18.0. VERL includes measurement instrumentation
and documented compatibility repairs. Environment records preserve
versions, source identifiers, working-copy status, and the container
checksum. Later controls use immutable source copies; the historical
source-record limitation is stated in Section~\ref{reproducibility}.

\subsection{Training setup and configuration levels}\label{training-setup-and-configuration-levels}

All reported runs use standard GRPO training \cite{shao2024deepseekmath}
with LoRA adapters \cite{hu2022lora}. The primary allocation places one vLLM
generation worker on each of two GPUs; a worker does not split its model
across GPUs. Fully Sharded Data Parallel (FSDP) partitions the actor's
training state across the allocation.

The boundary study uses Qwen2.5-3B-Instruct \cite{qwen2024qwen253b},
Phi-4-mini-instruct \cite{microsoft2025phi4mini}, and
Granite-3.3-2B-Instruct \cite{ibm2025granite33}, with approximately 3.1,
3.8, and 2.5 billion stored floating-point parameters, respectively.
The names identify the released models; their nominal size labels are
not exact parameter counts. State-release and original
temporal tests also use Qwen2.5-1.5B-Instruct. Tables omit the
instruction-tuned suffix; prose uses Qwen, Phi, and Granite when the
size is unambiguous.

Adapters of rank 64 and scale parameter alpha 32 attach to the selected
linear layers, excluding the output head. Training computations and
generation use 16-bit bfloat16 (BF16), while the sharded actor parameters
and gradient reduction use 32-bit floating point (FP32). The distinction
between stored parameters and computation precision matters when
estimating resident memory.
Gradient checkpointing recomputes intermediate activations to reduce
stored state, and padding removal skips padding tokens. Training samples
responses, while validation selects the most probable next token.
Kullback--Leibler (KL) divergence penalizes departure from the reference
policy through the actor loss, not the reward. Supplementary Section S11
lists the unchanged optimizer, decoding, and regularization settings.

Table~\ref{tab:workloads} gives the workloads used for the repeated boundary and batch/reservation experiments. Prompt and response lengths are upper limits; individual samples may be shorter. The log-probability micro-batch applies to policy and reference log-probability scoring.

\begin{table*}[!t]
\centering
\caption{Workload settings for boundary and batch/reservation experiments.}\label{tab:workloads}
\footnotesize
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}
  >{\raggedright\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1765}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1176}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1176}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1176}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1176}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1176}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1176}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 14\tabcolsep) * \real{0.1176}}@{}}
\toprule\noalign{}
\begin{minipage}[b]{\linewidth}\raggedright
Workload
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Prompt cap
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Response cap
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Model-length cap
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Max sequences
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Rollouts per prompt
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Global batch
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Log-prob. micro-batch
\end{minipage} \\
\midrule\noalign{}
GSM8K & 1,024 & 2,048 & 3,072 & 64 & 2 & 32 & 4 \\
MATH & 512 & 512 & 1,024 & 128 & 2 & 64 & 8 \\
Standard code & 640 & 1,024 & 1,664 & 64 & 2 & 32 & 4 \\
Longer-prompt code & 1,536 & 1,024 & 2,560 & 64 & 2 & 32 & 4 \\
\bottomrule
\end{tabular}
\end{table*}

The model-length cap bounds the combined prompt and response; the sequence cap bounds the number of simultaneously active generation sequences. Each boundary and batch/reservation process performs one training iteration. Supplementary Section S12 reports preparation-subset sizes and filtering. Other experiments use the settings specified in their respective protocols below.

\begin{table}[!t]
\centering
\caption{Compound configuration levels used in the boundary study.}\label{tab:levels}
\footnotesize
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}
  >{\raggedright\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2143}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2857}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2857}}
  >{\raggedright\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2143}}@{}}
\toprule\noalign{}
\begin{minipage}[b]{\linewidth}\raggedright
Level
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Actor micro-batch per GPU
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
vLLM reservation
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedright
Actor parameter offload
\end{minipage} \\
\midrule\noalign{}
c0 & 1 & 0.30 & Enabled \\
c1 & 4 & 0.45 & Enabled \\
c2 & 8 & 0.60 & Disabled \\
c3 & 16 & 0.70 & Disabled \\
c4 & 16 & 0.80 & Disabled \\
c5 & 32 & 0.85 & Disabled \\
\bottomrule
\end{tabular}
\end{table}

Table~\ref{tab:levels} defines the six configuration levels, c0--c5. They jointly increase actor micro-batch size and generation-memory reservation, with actor parameter offload disabled above c1. They are ordered test settings, not equally spaced values of one variable, so the comparison cannot isolate the effect of an individual control. Optimizer offload is disabled and generation-state release is enabled throughout the boundary grid.

\subsection{Experimental coverage}\label{experimental-coverage}

Table~\ref{tab:attempts} separates planned slots, actual attempts, and
eligible outcomes in the original studies.

\begin{table*}[!t]
\centering
\caption{Recorded attempts for the original 588 planned configuration--seed slots. Completed runs and memory failures are the retained outcomes; excluded attempts are additional records.}\label{tab:attempts}
\small
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}lrrrrr@{}}
\toprule\noalign{}
Study & Planned slots & Recorded attempts & Completed & Memory failures & Excluded \\
\midrule\noalign{}
Three-model boundary & 216 & 251 & 156 & 60 & 35 \\
Paired state release & 36 & 41 & 27 & 9 & 5 \\
Batch/reservation & 144 & 161 & 144 & 0 & 17 \\
Original 40-step runs & 18 & 18 & 15 & 3 & 0 \\
Original 100-step runs & 12 & 14 & 12 & 0 & 2 \\
Sampling calibration & 12 & 12 & 12 & 0 & 0 \\
Allocator-instrumentation control & 72 & 76 & 60 & 12 & 4 \\
Paired 100-step follow-up & 24 & 27 & 24 & 0 & 3 \\
Four-GPU transfer & 54 & 57 & 54 & 0 & 3 \\
\textbf{Total} & \textbf{588} & \textbf{657} & \textbf{504} & \textbf{84} & \textbf{69} \\
\bottomrule
\end{tabular}
\end{table*}

The targeted batch-by-logging control adds 24 eligible outcomes from
26 attempts; the admission panel adds 48 from 48. Before the larger-model
panels, these studies therefore contain 660 eligible processes from
731 attempts. The larger-model panels have separate planned-slot and
eligibility counts in Section~\ref{larger-model-results}. Sixteen supporting
historical screens and abandoned-scope observations remain separate.
Supplementary Section S1 gives the exclusions and missing records.

Every completed boundary run executes one global batch and has a length
summary; the sixty failures do not. Model-specific filtering can change
which examples reach that batch. Supplementary Section S12 reports these
counts and realized lengths without treating missing summaries as zero
work.

\subsection{Transfer between execution settings}\label{transfer-between-models}

Each model uses all four workloads and six levels
(Table~\ref{tab:levels}), with three seeds per configuration. Qwen and
Phi use seeds 41--43 for mathematics and 51--53 for code; Granite uses
91--93. Development runs checked that each case spanned within-margin
and unsuitable settings. Peak contrasts match workload and level and
require all three runs to complete for both models. Model choice also
changes architecture, parameter count, and tokenizer.

The retrospective workload baseline uses one donor's six-level profile
to predict the other workloads for that model; collecting it requires
eighteen eligible processes. Every donor choice is evaluated. Model
transfer instead copies the matched label from another model, following
the task contract in Section~\ref{benchmark-tasks-and-evaluation}.

The four-GPU study retains one generation worker per GPU without splitting an individual worker's model. Three models, two mathematics workloads, levels c2--c4, and seeds 111--113 give 54 processes. Global batch, rollout count, and the remaining settings are unchanged. We compare its labels in both directions with the earlier two-GPU results. Because GPU count was not randomized within a common experimental period, this is a transfer test rather than an isolated causal estimate of adding GPUs.

\subsection{Estimators beyond label copying}\label{estimation-methods}

We also test whether model structure and configuration settings help
predict memory outcomes. This comparison uses a separate fitting protocol,
not the task-local donor restriction above. Its historical pool comprises
the 72 boundary configurations and eighteen four-GPU configurations.
Each configuration is one observation combining three eligible seeds.
In each of three retrospective tests, all thirty configurations from one
model family are withheld and the other sixty supply fitting evidence.
Thus, no seed, workload, or GPU-count variant of the test family enters
the fit. The public historical results were visible during method design;
this is held-out evaluation, not blind method development.

The first baseline copies a donor label. Donors must match workload and
compound level; selection then prefers the same GPU count, the same
model family, and the nearest parameter count, in that order. A fixed
identifier resolves ties. This rule uses settings, not target outcomes.
The two fitted baselines instead use eight size-related features derived
from checkpoint headers (tensor shape and type metadata), model
architecture, and execution settings.
They describe actor shards, adapter optimizer state, generation reservation
and replicas, large model units, activation-related volumes, and
actor residency during generation. Supplementary Section S16 gives
their definitions.

\emph{Component regression with a startup guard} fits the completed-run
peak as an intercept plus a nonnegative weighted sum of these features.
Only configurations with three completions supply numerical peak targets.
Failure peaks are neither set to capacity nor replaced by a survivor's
peak. Coefficients summarize this dataset; they are not separately
identified physical memory components. The method is an empirical
baseline, not a reproduction of DNNMem, LLMem, or ReaL.

An additional one-sided check tests whether resident actor shards plus
the requested generation budget already exceed device capacity:
\begin{equation}
  \frac{4(P+R)}{G}+uC>C,
  \label{eq:startup-budget}
\end{equation}
where \(P\) and \(R\) are base-model and adapter parameter counts,
\(G\) is the number of actor GPUs, \(u\) is the reservation fraction,
and \(C\) is capacity in bytes. The factor four represents FP32 storage.
The check applies only without actor parameter offload. It counts
generation storage within its budget and adds no separate reference copy.
A positive check predicts memory failure; a negative check is not an
approval. Otherwise, the fitted peak determines the three-state prediction
using the capacity and operating-limit thresholds. The release preserves
both this final label and the label before the startup check.

The second fitted baseline is a regularized multinomial logistic
classifier: it learns a linear score for each outcome class and selects
the largest. It uses all source labels, including failures.
Feature scaling is learned within each fitting set. Regularization,
class weighting, feature definitions, and decision rules are fixed
without a parameter search; classifier scores are not calibrated
failure probabilities. Supplementary Section S16 gives the complete
specification and acquisition counts.

For prospective size transfer, we froze all three methods' predictions
for twelve Qwen2.5-7B-Instruct configurations before any target execution.
The fit uses all ninety historical configurations. The target contains
approximately 7.6 billion stored floating-point parameters and uses
GSM8K, MATH, and longer-prompt code at levels c2 and c3 on two or four
GPUs. This tests a larger model within the already known Qwen family
and hardware setting, not transfer to a new architecture or device type.
Earlier 7B exploration used other workflows and is excluded from fitting.

The frozen plan assigns three seeds to each configuration, giving
36 invocations. Eighteen allocations each reserve four GPUs and
192 GiB of host memory, then run a two-GPU and a four-GPU condition
sequentially. Period order is randomized and
balanced; each two-of-four device subset occurs three times. Fresh
processes, physical-device checks, and all-device idle checks separate
the periods. Model, workload, global prompt batch, level, and seed
match within each pair. Generated responses may differ, so the contrast
concerns the total execution consequence of GPU count, not pure sharding
of identical tensors.

Each invocation requests one training step with full logging, without
validation, checkpoint writing, or restoration. No retry or replacement
is permitted. A repeated label requires all three eligible seeds;
unresolved configurations remain in the inventory, with each method's
unscored approvals reported separately. Host-memory exhaustion does
not establish a GPU-memory failure. Task-provisioned GPU time and
the four-GPU reservation cost are also separated. Supplementary
Section S16 records the specification, execution-source changes,
missingness, and cost accounting.

The initial four-GPU c2 runs were interrupted by host-memory exhaustion.
We therefore froze a separate c2 follow-up under an expanded host-resource
condition, with 384 GiB of host memory and the processor allocation fixed
within each pair. It covers all three original workloads with three new
seeds, giving eighteen invocations in nine matched allocations.
The original predictors, donor choices, and thresholds remain unchanged.
This follow-up was motivated by the initial observations; it is not an
independently selected new workload sample. Its labels and costs are
reported separately, without replacing or pooling the original slots.
The within-pair comparison concerns GPU count under the new host
condition, not an isolated effect of increasing host memory between panels.

\subsection{Budgeted admission with separate evaluation runs}\label{prospective-admission}

To test the value of already available measurements, we specified a
fresh panel before collecting its outcomes. Qwen2.5-3B and Phi-4-mini are
each evaluated on GSM8K and MATH, on two GPUs, at levels c2--c4. All
targets use prompt and response caps of 1,024 tokens, four responses per
prompt, a combined model-length cap of 2,048 tokens, and five training
steps. Full allocator logging is enabled. Global batches, active-sequence limits,
and log-probability micro-batches retain the task-specific values in
Table~\ref{tab:workloads}. The full training split is used after filtering,
in fixed order. Validation and checkpoint writing occur only at step 5.
Validation uses the first 32 eligible test examples for GSM8K and 64
for MATH.
This is a compound workload and schedule change, not a single-factor test.

Each of the twelve target configurations has four fresh processes.
Seed 141 supplies the only queryable screen, with the complete
five-step schedule. Seeds 142--144 independently
form the three-repeat evaluation label. Screening measurements therefore
do not contribute to the outcome against which their decisions are judged.
The matched original boundary configuration supplies donor evidence.
Target settings, source records, seed roles, screening order, rules,
and budgets were frozen before execution. Physical collection order is
randomized with a recorded seed.

Screening orders were randomly assigned before execution: c3, c2, c4
in both Qwen cases and Phi/MATH, and c4, c3, c2 in Phi/GSM8K.
Every rule uses the same order within a case.

We compare three simple rules. \emph{Source copy} initially approves
the donor's within-margin configurations. A \emph{headroom guard}
additionally requires the donor peak to leave another 2,048 MiB below
the operating limit. This is an engineering choice made with the
historical corpus visible, not a calibrated risk bound. \emph{Direct
screening} starts without a decision on any target and uses no donor
measurements.
A within-margin screen changes that candidate to approve; above-margin
completion or memory failure changes it to reject; unresolved
noncompletion causes abstention. Unqueried candidates retain the initial
rule's decision.

Offline replay reveals only requested screens and charges each invocation
before revealing its outcome, at budgets of zero to three attempts per
case. Unresolved targets remain explicit, and unstarted work is not
charged. Supplementary Section S9 specifies the frozen setup-repair
limits, missing-outcome bounds, abstention, and stopping rules.

Incremental effort counts target attempts when donor evidence already
exists. Cold-start accounting adds the nine historical donor attempts
per case for transfer rules. The full screening/evaluation panel is
research cost, not freely available method evidence. Attempts differ
in work: donors execute one step and targets five. The comparison does
not test spending a donor-sized budget on repeated direct screening.

\subsection{State-release and micro-batch experiments}\label{memory-mechanism-and-100-step-experiments}

To test whether retaining generation state limits completion, the
release experiment runs both conditions sequentially on the same
node and GPUs, with half of the pairs release-first and half resident-first.
Before each period, combined idle memory must be below 2,048 MiB across
the two GPUs. Eligible pairs require both records and identical GPU
identities. This aggregate check differs from the later per-GPU check.

Release uses vLLM Sleep Mode level 1 to suspend generation workers after
initialization or generation. Weights move to host memory and the KV
cache is discarded. The measured LoRA implementation restores weights
before synchronization, transfers base weights when first needed and
adapter updates thereafter, then restores cache capacity before generation
resumes. Resident mode disables this cycle. Both conditions keep adapters
separate from base weights, use the same weight-transfer mechanism, and
perform one training iteration without validation or checkpoints.
Section~\ref{releasing-generation-state-changes-completion} gives all six
\emph{base configurations}, the shared settings before release is varied.
Each uses three seeds.

A separate \emph{factorial experiment} combines actor micro-batches 8 and
16 with vLLM reservations 0.60 and 0.70 across three models, four
workloads, and three seeds. Each model--workload--seed block contains
four conditions. A factor contrast averages its difference over the
other factor; an interaction measures dependence of that difference
on the other factor.

These 144 processes ran in separate allocations across twenty nodes,
without randomized placement or order within blocks. They are analytical
groupings, not same-GPU comparisons. Label comparisons use all blocks;
pairwise peaks require both completions and factorial peak contrasts
require all four. The retrospective stage reanalysis uses the same
blocks; the control below repeats the batch contrast on the same GPUs.

\subsection{Measurement controls}\label{follow-up-controls-and-transfer-tests}

These controls test whether sampling and allocator logging alter the
reported outcomes or stage contrasts.
Sampling calibration compares 10 ms and 100 ms external intervals in
six matched configuration pairs, not same-allocation pairs. Separately,
the 10 ms traces are resampled at intervals up to 200 ms with different
starting offsets. Supplementary Section S8 gives the settings.

The instrumentation control covers the three models on GSM8K and MATH
at each model's highest within-margin level and the next level, using
seeds 111--113. Each of 36 allocations runs two fresh processes on the
same GPUs. The \emph{external-only} condition retains NVML sampling and
stage markers. The \emph{full} condition additionally synchronizes GPU
work before each traced worker operation, resets allocator peak counters,
and records statistics when the operation returns, without another
synchronization. Waiting for outstanding work can change timing and
stage attribution.

The two orders each occur in eighteen allocations. Each period requires
idle memory below 1,024 MiB on every GPU. Completion and margin-label
disagreements use all eligible pairs; peak and time contrasts require
both completions. This comparison concerns added allocator logging,
not the cost of all measurement activity.

The new batch-by-logging control uses Phi/GSM8K, where the existing stage
measurements vary most, and Qwen2.5-3B/longer-prompt code, which adds code
coverage. Each of three seeds (121--123) receives four fresh processes on
the same two GPUs: micro-batch 8 or 16, each with external-only or full
logging. Reservation is fixed at 0.60 and other workload settings follow
Table~\ref{tab:workloads}. The six blocks use fixed counterbalanced
condition orders, idle-device checks, an immutable source checkout,
and no validation or checkpoints.

The actor-stage batch effect subtracts the batch-8 peak from the batch-16
peak; the logging interaction subtracts the external-only batch effect
from the full-logging effect. These are the primary outcomes.
A pre-execution 512 MiB reference flags potentially material differences,
not a certified equivalence margin. Every block and any incomplete
attempt are retained.

\subsection{Testing one-step screens over longer runs}\label{testing-one-step-screens-over-longer-runs}

To test whether short-run labels hold over a longer schedule, the
paired duration test covers Phi and Granite on GSM8K and MATH with
seeds 111--113. Each allocation runs a fresh one-step screen and a
separate 100-step process. Actor micro-batch is 16; reservations 0.65
for Phi and 0.75 for Granite interpolate between their earlier tested
levels and were fixed before these outcomes. Both horizons use the
filtered full training split in fixed order. Validation occurs before
training and every twenty steps, checkpoint writing every 25 steps,
and both at the final step, including step 1. Runs start without
checkpoint restoration; only the latest saved state is kept. Long runs
remain in the comparison even when their screen exceeds the margin.
Completion checks cover every requested update and scheduled operation.
The primary comparison combines three repetitions; individual pairs
are reported separately.

Earlier tests cover Qwen2.5-3B/GSM8K and Qwen2.5-1.5B/MATH. Three
settings per case and three seeds give eighteen forty-step runs; the
below-limit and near-boundary settings also receive twelve 100-step
runs. Their sixteen historical screens include only one for the
unsuitable MATH setting, rather than three. The forty-step runs omit
validation and checkpoints, while the 100-step extension includes both.
Supplementary Section S14 gives these distinct workloads and schedules.

Besides completion and label agreement, we report later growth relative
to each long run's own first-step peak and compare validation/checkpoint
peaks with the maximum over other stages.

\subsection{Statistics}\label{statistics}

The analysis is descriptive. We report configuration counts, per-case
results, and differences within matched allocations. Repeated seeds
test execution repeatability; they are not new workloads or independent
samples of a deployment population. Transfer comparisons keep complete
model--workload cases together, following the emphasis on implementation
and few-run uncertainty in reinforcement-learning evaluation
\cite{henderson2018matters,agarwal2021precipice}.

The main paper emphasizes observed ranges and agreement in direction.
The supplement retains the earlier group-resampling summaries and a
sensitivity analysis that gives the two code subsets half weight each.
Those calculations describe dependence on the selected cases; they do
not provide population-risk bounds or compensate for the small number
of distinct workloads.

\section{Results}\label{results}

We first report configuration outcomes (RQ1), then examine state release
and stage measurements (RQ2), followed by short/long agreement (RQ3).
Transfer, budgeted configuration decisions, and fitted prediction
comparisons complete RQ1.

\subsection{Completion and memory margin}\label{completion-and-memory-safety}

Of the 72 configurations in the three-model boundary experiment, 44
complete within margin, eight complete above it, and twenty have memory
failures (Table~\ref{tab:boundary}). Their three repetitions give 216
eligible processes. The sixty failing processes stop
during generation initialization (51), generation (six), or weight
synchronization (three).

All three repetitions agree within each configuration.

\begin{table*}[!t]
\centering
\caption{Completion and margin compliance in the original boundary experiment.}\label{tab:boundary}
\footnotesize
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}
  >{\raggedright\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1304}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1739}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1739}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1739}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1739}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1739}}@{}}
\toprule\noalign{}
\begin{minipage}[b]{\linewidth}\raggedright
Model
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Processes
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Completed
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Within margin
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Memory failures
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Within-margin configurations
\end{minipage} \\
\midrule\noalign{}
Qwen2.5-3B & 72 & 48 & 48 & 24 & 16/24 \\
Phi-4-mini & 72 & 48 & 36 & 24 & 12/24 \\
Granite-3.3-2B & 72 & 60 & 48 & 12 & 16/24 \\
\textbf{Total} & \textbf{216} & \textbf{156} & \textbf{132} & \textbf{60} & \textbf{44/72} \\
\bottomrule
\end{tabular}
\end{table*}

Figure~\ref{fig:boundary} shows where each outcome occurs within the tested configuration levels.

\begin{figure*}[!t]
\centering
\pandocbounded{\includegraphics[keepaspectratio,alt={Three-state feasibility profiles across models, workloads, and configuration levels. Profiles are invariant across the four workloads within each model.}]{figures/standard_grpo_boundary.pdf}}
\caption{Three-state feasibility profiles across the boundary grid. Each cell combines three fresh processes. Identical profiles within a model explain the success of the donor-workload lookup baseline.}\label{fig:boundary}
\end{figure*}

\subsection{Releasing generation state changes completion}\label{releasing-generation-state-changes-completion}

In the eighteen same-GPU pairs, release succeeds and resident fails in
nine; both complete in the other nine. No pair completes only in resident
mode. Table~\ref{tab:release} gives every base configuration. Six resident
failures occur during weight synchronization and three during actor update.
These pairs would disappear from a comparison requiring two completed
peaks, even though they contain the main completion result.

\begin{table*}[!t]
\centering
\caption{All state-release base configurations. Prompt/response limits are tokens; their sum is the model-length limit. The selected training subset equals the global batch. Actor and log-probability micro-batches are per GPU; the latter applies to both policy and reference scoring. Completed counts are release / resident, each out of three.}\label{tab:release}
\small
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}llrrrrrlr@{}}
\toprule\noalign{}
Model & Workload & \shortstack{Prompt /\\response cap} &
\shortstack{Max.\\sequences} & \shortstack{Rollouts /\\prompt} &
\shortstack{Global\\batch} & \shortstack{Actor / log-prob.\\micro-batch} &
\shortstack{Reservation;\\actor offload} & Completed \\
\midrule\noalign{}
Qwen2.5-1.5B & GSM8K & 1,024 / 2,048 & 64 & 2 & 32 & 16 / 8 & 0.70; no & 3 / 3 \\
Qwen2.5-1.5B & MATH & 512 / 512 & 128 & 2 & 64 & 16 / 8 & 0.70; no & 3 / 0 \\
Qwen2.5-3B & GSM8K & 1,024 / 2,048 & 64 & 2 & 32 & 1 / 4 & 0.30; yes & 3 / 3 \\
Qwen2.5-3B & GSM8K & 256 / 1,024 & 256 & 5 & 128 & 16 / 8 & 0.65; no & 3 / 0 \\
Qwen2.5-3B & MATH & 1,792 / 1,024 & 256 & 5 & 128 & 16 / 8 & 0.65; no & 3 / 0 \\
Qwen2.5-3B & MATH & 1,792 / 1,024 & 256 & 5 & 128 & 2 / 8 & 0.35; yes & 3 / 3 \\
\bottomrule
\end{tabular}
\end{table*}

Among the nine pairs where both conditions complete, retaining generation
state increases the mean peak by 7,061 MiB. This contrast concerns only
three base configurations. Release-only completion appears in both
execution orders: five of nine release-first pairs and four of nine
resident-first pairs. The supplementary plot and intervals retain the
order and grouping information. Throughput and latency costs of release
were not the objective of this experiment.

\subsection{Stage-level and overall memory contrasts}\label{the-overall-peak-hides-the-training-batch-effect}

All 144 batch/reservation processes complete: 120 within margin and
24 above it, giving forty within-margin and eight above-margin
configuration labels. None fails for memory.

The higher vLLM reservation, 0.70 rather than 0.60, is associated with a
mean peak increase of
3,998 MiB, close to the additional tenth of device capacity reserved.
All Phi configurations at reservation 0.70 exceed the operating limit;
their matched 0.60 configurations remain within it. Qwen and Granite
retain their labels. The peak increase occurs across all three models.

The batch-16 and batch-8 configurations have identical labels, and their
mean overall peaks differ by only \(-31\) MiB. This small difference
does not mean that processing more sequences has little memory cost.

The stage-specific reanalysis of the 36 four-condition blocks finds
much larger batch contrasts during actor update: 3,980 MiB in externally
sampled device memory and 3,848 MiB in allocated tensor memory
(Table~\ref{tab:factorial}). The latter takes the maximum across training
workers. These runs used separate allocations without randomized placement or order,
so the contrasts alone do not isolate causal effects. The matched
controls below test whether the actor-stage batch contrast persists
under tighter placement control and without allocator logging.

\begin{table*}[!t]
\centering
\caption{Mean descriptive contrasts in the original batch/reservation grid under full instrumentation. Placement and order were not randomized. Per-workload values and earlier resampling summaries are retained in the supplement.}\label{tab:factorial}
\small
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}
  >{\raggedright\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2000}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2667}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2667}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 6\tabcolsep) * \real{0.2667}}@{}}
\toprule\noalign{}
\begin{minipage}[b]{\linewidth}\raggedright
Configuration contrast
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Whole-run NVML peak (MiB)
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Actor-update NVML peak (MiB)
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Actor-update allocated peak (MiB)
\end{minipage} \\
\midrule\noalign{}
Actor micro-batch 8→16 & −31 & 3,980 & 3,848 \\
Reservation 0.60→0.70 & 3,998 & 9 & 1 \\
\bottomrule
\end{tabular}
\end{table*}

Actor-stage batch contrasts are positive in every workload, ranging
from 2,073 to 6,268 MiB in NVML memory. Giving the two related code
subsets half weight each retains this direction
(Supplementary Section S3).

Actor update determines the overall peak in none of the 144 traces.
Generation or weight synchronization dominates most runs; the remaining
peaks occur during initialization or unassigned idle intervals.
Consequently, substantial actor-stage growth can remain below another
stage's maximum. Figure~\ref{fig:logging} tests whether this contrast
persists without allocator instrumentation.

\begin{figure*}[!t]
\centering
\pandocbounded{\includegraphics[keepaspectratio,alt={Actor-stage batch-size effects under external-only and full instrumentation in the targeted control. Connected points share a seed and GPU allocation.}]{figures/review_instrumentation_batch.pdf}}
\caption{Targeted batch-by-logging control. Each connected pair compares the actor-stage batch-16 minus batch-8 effect under external-only and full instrumentation within one four-condition allocation. Asterisks identify additional allocations after initial noncompletion. These are observed block effects, not confidence intervals. Section~\ref{effect-of-allocator-instrumentation} reports the attempt history.}\label{fig:logging}
\end{figure*}

\subsection{Sensitivity to measurement}\label{effect-of-allocator-instrumentation}

Completion and margin labels agree between logging conditions in the
36 eligible pairs, although stage contrasts can change.
Both conditions complete in thirty.
Their mean full-minus-external differences are \(-21.4\) MiB for the
whole-run peak and \(-1.4\) seconds for elapsed time. Supplementary
Section S15 reports each base configuration.

There are forty external-only and 36 full-logging attempts. Two external
attempts have setup errors; two time out at startup with unresolved
cause and no full-logging counterpart. Excluding diagnosed setup errors
leaves 38 allocation attempts and zero to two possible disagreements
(0--5.3\%). This is a missing-outcome range, not an observed disagreement
rate or evidence of equivalence.

Actor-stage peaks are available in 33 pairs, including three that fail
later. Individual full-minus-external differences range from \(-1,800\)
to 1,456 MiB; base-configuration medians range from \(-176\) to 400 MiB.
Qwen/MATH c4 fails before actor update. These stage differences motivated
the direct batch-by-logging control (Supplementary Section S2).

That control initially completes four of six allocations: sixteen
processes finish within margin, and two full-logging processes, both
first in order, reach the twenty-minute limit. One reports an accelerator
argument error during weight transfer; the other remains unexplained.
Neither is diagnosed as OOM, and the six remaining conditions never
start. A bounded amendment permits one unchanged additional allocation
per incomplete block, retaining the initial outcomes
(Supplementary Section S6).

Both additional allocations complete, giving six complete four-condition
blocks and 24 within-margin completions among 26 attempts. Actor-stage
batch contrasts are positive under external-only measurement in every
complete block: case means are 1,966 MiB for Phi/GSM8K and 6,430 MiB for
Qwen/longer-prompt code (Figure~\ref{fig:logging}). Full logging gives
2,287 and 7,059 MiB, respectively. The logging interaction ranges from
\(-220\) to 1,054 MiB; three of six blocks exceed the 512 MiB diagnostic
in absolute value. Whole-run batch contrasts remain between \(-160\)
and 132 MiB.

The actor-stage increase persists without allocator logging, but its
magnitude depends on measurement and generated work: matched prompts
and seeds do not produce identical responses. The two initial failures
also cannot separate logging from order, seed, or allocation.
Supplementary Section S6 retains every block and response-length summary.

\label{measurement-calibration}
All twelve sampling-calibration runs complete. Coarser resampling of the
10 ms traces changes neither their observed peaks nor assigned stages.
This supports 100 ms sampling for the sustained peaks in these traces
(Supplementary Section S8).

\FloatBarrier
\subsection{Short tests and longer execution}\label{longer-runs-retain-labels-despite-memory-growth}

\label{longer-run-validation-on-phi-and-granite}

The paired study compares twelve fresh one-step screens with separate
100-step runs. All long runs complete. Two individually within-margin
screens are paired with above-margin long runs, both for Granite on
MATH. Another short repetition already exceeds the limit,
so the three-repeat short-run label already classifies that case
as above-margin.

Table~\ref{tab:horizon} distinguishes individual outcomes from the label
requiring all three repetitions to complete within margin.

\begin{table*}[!t]
\centering
\caption{One-step and 100-step outcomes, with memory measurements from completed long runs. Later growth is relative to each long run's own first-step peak, not the separate screen.}\label{tab:horizon}
\footnotesize
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}
  >{\raggedright\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.2857}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1429}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1429}}
  >{\raggedright\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1429}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1429}}
  >{\raggedleft\arraybackslash}p{(\linewidth - 10\tabcolsep) * \real{0.1429}}@{}}
\toprule\noalign{}
\begin{minipage}[b]{\linewidth}\raggedright
Model / workload
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Screen completed; within margin
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Long completed; within margin
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedright
Repeated labels
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Mean later growth (MiB)
\end{minipage} & \begin{minipage}[b]{\linewidth}\raggedleft
Mean validation / checkpoint peak (MiB)
\end{minipage} \\
\midrule\noalign{}
Granite-3.3-2B / GSM8K & 3/3; 3/3 & 3/3; 3/3 & within → within & 159 & 38,443 / 13,498 \\
Granite-3.3-2B / MATH & 3/3; 2/3 & 3/3; 0/3 & above → above & 657 & 38,875 / 15,039 \\
Phi-4-mini / GSM8K & 3/3; 3/3 & 3/3; 3/3 & within → within & 115 & 37,581 / 19,581 \\
Phi-4-mini / MATH & 3/3; 3/3 & 3/3; 3/3 & within → within & 590 & 37,883 / 24,620 \\
\bottomrule
\end{tabular}
\end{table*}

The three initially within-margin cases retain that repeated label.
All long runs pass the required training, validation, and checkpoint
checks. Later growth compares each long run with its own first step,
not with the separate short-run peak.

\paragraph*{Earlier duration tests.}
In the forty-step study, all twelve runs from initially within-margin
settings complete within margin. Of six from unsuitable settings,
three complete above margin and three fail during generation
initialization. All eighteen outcomes agree with the historical screens,
including the single-screen exception. Among fifteen completions,
later growth over step 1 averages 1,717 MiB and reaches 2,404 MiB.

The original 100-step extension completes twelve of fourteen attempts.
Two Qwen/GSM8K attempts stop after 63 and 77 steps: one reports a
CUDA invalid-argument error during weight transfer; the other stops
progressing during synchronization with unresolved cause. Neither
establishes OOM. Their replacements complete, leaving twelve eligible
within-margin outcomes. Among these completions, later growth averages
1,925 MiB, and validation/checkpoint peaks remain below other stages.
Supplementary Sections S1 and S5 preserve the attempt history and
case-level contrasts.

\subsection{Simple lookup and cross-model transfer}\label{model-labels-are-not-interchangeable}

Within each model, the full six-level, three-state profile is identical
across the four workloads. Donor-workload lookup therefore predicts
every remaining workload label correctly: 216 comparisons across twelve
donor choices involve 72 distinct targets, not 216 independent
observations. This grid does not demonstrate a need for a learned
workload-specific predictor.

The profiles differ between models. Qwen and Granite remain within
margin through c3, whereas Phi does so through c2.
Table~\ref{tab:model-transfer} shows the consequences of copying them.

\begin{table*}[!t]
\centering
\caption{Source-model lookup at the primary margin. Each direction compares
24 target configurations. Approval errors distinguish memory failure
from completion above margin.}\label{tab:model-transfer}
\small
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}lrrrrr@{}}
\toprule\noalign{}
Source $\rightarrow$ target & \shortstack{Correct\\three-state label} &
Approved & \shortstack{Approved:\\memory failure} &
\shortstack{Approved:\\above margin} & \shortstack{Rejected:\\within margin} \\
\midrule\noalign{}
Qwen $\rightarrow$ Phi & 20 & 16 & 0 & 4 & 0 \\
Granite $\rightarrow$ Phi & 16 & 16 & 0 & 4 & 0 \\
Phi $\rightarrow$ Qwen & 20 & 12 & 0 & 0 & 4 \\
Phi $\rightarrow$ Granite & 16 & 12 & 0 & 0 & 4 \\
Qwen $\rightarrow$ Granite & 20 & 16 & 0 & 0 & 0 \\
Granite $\rightarrow$ Qwen & 20 & 16 & 0 & 0 & 0 \\
\bottomrule
\end{tabular}
\end{table*}

Copying Qwen's labels to Phi approves four above-margin settings and no
memory failures. Those four are four of twelve unsuitable targets, or
four of sixteen approvals: the denominators answer different questions.
Qwen and Granite approve the same settings, but their three-state
profiles differ at c4, where Granite completes above margin and Qwen
fails.

The selected margin matters. Qwen and Phi have the same completion
boundary when the full device capacity is allowed. Supplementary
Section S15 retains the five-threshold sensitivity analysis; Section S7
gives completed-run peak contrasts between models.

\subsection{Transfer between GPU counts}\label{transfer-between-gpu-counts}

On four GPUs, all 54 processes complete and 48 leave the specified margin,
giving sixteen within-margin configurations out of eighteen.

\begin{table*}[!t]
\centering
\caption{Outcomes at the same levels on two and four GPUs. ``Within''
and ``above'' distinguish completed outcomes relative to the margin;
``failure'' denotes memory failure.}\label{tab:gpu-transfer}
\small
\setlength{\tabcolsep}{3pt}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}lll@{}}
\toprule\noalign{}
Model / workload & Two-GPU c2 / c3 / c4 & Four-GPU c2 / c3 / c4 \\
\midrule\noalign{}
Granite-3.3-2B / GSM8K & within / within / above & within / within / within \\
Granite-3.3-2B / MATH & within / within / above & within / within / within \\
Phi-4-mini / GSM8K & within / above / failure & within / within / above \\
Phi-4-mini / MATH & within / above / failure & within / within / above \\
Qwen2.5-3B / GSM8K & within / within / failure & within / within / within \\
Qwen2.5-3B / MATH & within / within / failure & within / within / within \\
\bottomrule
\end{tabular}
\end{table*}

Across the eighteen matched configurations, two-to-four-GPU transfer
wrongly rejects six within-margin settings and makes no approval error.
Reverse transfer approves two memory-failing and four above-margin
settings: six of eight unsuitable targets, or six of sixteen approvals.
The c2--c4 range does not establish the four-GPU boundary beyond these
levels.

Exact label accuracy alone can favor a worse approval rule: always
predicting within-margin completion gets more labels right than source
copying but approves more memory failures
(Table~\ref{tab:accuracy-diagnostic}). Always rejecting avoids approval
errors while recovering no within-margin setting.

\begin{table}[!t]
\centering
\caption{Diagnostic rules on the 36 GPU-transfer queries. ``Always reject''
predicts memory failure for every target. Counts are decisions, not
deployment-risk estimates.}\label{tab:accuracy-diagnostic}
\footnotesize
\setlength{\tabcolsep}{3pt}
\begin{tabular}{@{}p{0.28\linewidth}rrrr@{}}
\toprule
Rule & \shortstack{Correct\\labels} & \shortstack{Within-margin\\approved} &
\shortstack{Failure\\approved} & \shortstack{Above\\approved} \\
\midrule
Source copy & 20 & 20 & 2 & 4 \\
Always approve & 26 & 26 & 4 & 6 \\
Always reject & 4 & 0 & 0 & 0 \\
\bottomrule
\end{tabular}
\end{table}

\subsection{Existing evidence and the cost of new tests}\label{admission-results}

All 48 planned invocations supply validated outcomes: 32 complete and
16 fail for memory. There are no retries or unresolved slots. The
twelve screens and 36 separate evaluation runs agree at every candidate.
The repeated evaluation labels identify six within-margin candidates,
two above-margin candidates, and four with memory failures
(Table~\ref{tab:admission}). Every completed process performs all five
updates and the final validation and checkpoint operations.

\begin{table*}[!t]
\centering
\caption{Admission results for four prospective cases. Entries under
the rules count within-margin candidates approved / available.
Budget is requested target attempts per case. Every approval by
these rules is within margin at every tested budget.}\label{tab:admission}
\small
\setlength{\tabcolsep}{5pt}
\renewcommand{\arraystretch}{1.15}
\begin{tabular}{@{}llrrrrr@{}}
\toprule
& & \multicolumn{2}{c}{No target tests} &
\multicolumn{3}{c}{Direct-screening budget} \\
\cmidrule(lr){3-4}\cmidrule(l){5-7}
Model / workload & Evaluation c2 / c3 / c4 &
Source copy & Headroom guard & 1 & 2 & 3 \\
\midrule
Qwen2.5-3B / GSM8K & within / within / failure & 2/2 & 1/2 & 1/2 & 2/2 & 2/2 \\
Qwen2.5-3B / MATH & within / within / failure & 2/2 & 1/2 & 1/2 & 2/2 & 2/2 \\
Phi-4-mini / GSM8K & within / above / failure & 1/1 & 1/1 & 0/1 & 0/1 & 1/1 \\
Phi-4-mini / MATH & within / above / failure & 1/1 & 1/1 & 0/1 & 1/1 & 1/1 \\
\bottomrule
\end{tabular}
\end{table*}

With donors already available, source copy recovers all six within-margin
candidates without target tests. The guard rejects Qwen c3 in both
workloads, reducing the equally weighted mean of the four case recalls
to 75\%, without avoiding an approval error. After one query per case,
copy and guard decisions agree by construction: their only initial
differences are the two Qwen c3 candidates, both queried first.

Direct screening recovers no candidate before testing. Its
case-averaged recall rises to 25\%, 75\%, and 100\% at budgets of one,
two, and three attempts per case. The fixed order places Phi/GSM8K's
only within-margin candidate last. All nonempty approval sets have
100\% observed precision. Approving everything would also give full
recall, but would admit all four memory-failing and both above-margin
candidates.

At the first tested common per-case budget attaining full recall, the
incremental target-attempt totals are zero for source copy, four for
the guard, and twelve for direct screening. The transfer rules additionally
use 36 historical donor attempts, giving cold-start attributed totals of
36, 40, and 12 at those points. Attempts contain different amounts of
work, so these counts do not establish GPU-time savings or optimal
acquisition. The full panel's collection cost is reported in
Supplementary Section S10.

\subsection{Held-out-family estimation}\label{estimation-results}

Table~\ref{tab:estimators} shows that the fitted baselines do not
uniformly improve on donor copying. Component regression predicts every
Qwen label correctly and reduces Phi's margin-violating approvals,
but it approves all four memory-failing Granite configurations.
The classifier avoids those Granite failures but rejects six
within-margin Qwen configurations. No startup check changes a label
in these retrospective tests: these differences arise from the fitted
models and donor choices, not that override.

\begin{table*}[!t]
\centering
\caption{Held-out-family predictions. Each row evaluates thirty
configurations, with the other sixty used for fitting. ``Useful''
counts within-margin approvals. Within-margin, above-margin, and failure
counts are 22/0/8 for Qwen, 16/6/8 for Phi, and 22/4/4 for Granite.
Seeds are not additional test examples.}
\label{tab:estimators}
\small
\setlength{\tabcolsep}{5pt}
\begin{tabular}{@{}llrrrrrr@{}}
\toprule
Held-out model & Method & Correct labels & Approved & Useful &
\shortstack{Failure\\approved} & \shortstack{Above\\approved} &
\shortstack{Within\\rejected} \\
\midrule
Qwen & Donor copy & 26 & 22 & 22 & 0 & 0 & 0 \\
& Regression + startup guard & 30 & 22 & 22 & 0 & 0 & 0 \\
& Logistic classifier & 21 & 16 & 16 & 0 & 0 & 6 \\
Phi & Donor copy & 24 & 22 & 16 & 0 & 6 & 0 \\
& Regression + startup guard & 27 & 19 & 16 & 0 & 3 & 0 \\
& Logistic classifier & 24 & 18 & 16 & 0 & 2 & 0 \\
Granite & Donor copy & 26 & 22 & 22 & 0 & 0 & 0 \\
& Regression + startup guard & 22 & 30 & 22 & 4 & 4 & 0 \\
& Logistic classifier & 26 & 25 & 22 & 0 & 3 & 0 \\
\bottomrule
\end{tabular}
\end{table*}

The component model's mean absolute peak error ranges from 1.35 to
2.57 GiB across the three test families, using only configurations
with three completions. These errors do not include failure configurations
and therefore cannot replace the categorical evaluation.
The held-out-family comparison distinguishes the baselines, whereas
workload copying is already perfect on the original boundary grid.
Three familiar families are insufficient to select a generally
reliable predictor.

\subsection{Larger-model transfer and incomplete execution}\label{larger-model-results}

Only six of the twelve configurations in the original 7B panel received
complete repeated labels, all for startup memory-admission failure.
No invocation supplied a validated completion. The remaining configurations
were unresolved because of setup failures, host-memory exhaustion, or
unstarted slots; Supplementary Section S16 retains the complete accounting.

Donor copying approved all six resolved configurations incorrectly.
Both fitted methods predicted their failure labels correctly, but an
always-failure rule would do the same on this failure-only subset.
The regression's three within-margin predictions concern precisely the
four-GPU c2 configurations censored by host-memory exhaustion.
They are unscored approvals, not demonstrated successes.
The original panel thus identifies a failure of label copying under this
size change, but cannot establish useful-configuration discovery or a
completed-run memory benefit from additional GPUs.

The expanded-host follow-up resolves the two-GPU c2 configurations
to the same startup-failure outcome. Its four-GPU invocations exit
successfully and record update and weight-synchronization calls, but
lack the required final-step record. They therefore remain unresolved;
the recorded work does not justify treating their partial peaks as
completed-run measurements. This extension supplies no validated
completion and does not resolve the regression's approvals.
Supplementary Section S16 gives the separate counts and diagnostic evidence.

\section{Discussion}\label{discussion}

\paragraph*{Inspect stages before interpreting a configuration control.}
\label{why-stage-level-measurements-matter}
Whole-run peaks answer a capacity question, while stage peaks reveal
where demand changes. Generation or synchronization can mask actor-stage
growth. A small overall batch-size contrast therefore does not establish
that larger training batches have little memory cost. Paired release
outcomes also show why comparisons restricted to two successful runs
can omit the important completion change.

\paragraph*{Match the setting before reusing a profile.}
\label{what-can-be-transferred-between-configurations}
A four-GPU Qwen c4 record does not justify approving c4 on two GPUs:
the corresponding two-GPU configurations fail. A researcher can use the
archive to shortlist settings measured under closer execution conditions,
then test a changed workload or schedule. The relevant comparison is
not label accuracy alone, but how many within-margin candidates are
recovered and how many failing or above-margin candidates are approved.
The fitted baselines also require this check; their errors differ by
model. The study does not rank configurations by throughput, training
quality, or economic value.

\paragraph*{Test the intended schedule.}
\label{how-to-use-a-short-run-screen}
Validation and checkpoint writing belong in a screen when they belong
in the intended execution. Repetition identified the measured
Granite--MATH margin crossing that individual short tests missed, but
does not establish a universal repetition count. Retain all-cause
noncompletion separately from the conditional memory label.

\section{Threats to validity}\label{threats-to-validity}

\paragraph*{Measurement.}\label{construct-validity}
Margin compliance depends on the chosen operating limit. Sampling can
miss shorter transients, and stage markers identify when a peak or failure
is observed, not the origin of every contributing allocation. Agreement
in whole-run outcomes under logging controls therefore does not establish
unchanged stage timings or exact operation-level memory demand.

\paragraph*{Comparisons and selected cases.}\label{internal-and-statistical-validity}
Compound levels change several controls; model choice also changes
architecture, size, tokenizer, and sometimes filtered examples.
Historical factorial blocks and GPU-count comparisons do not control
allocation and experimental period. The targeted batch-by-logging control
addresses placement in two selected cases, not the whole grid, and still allows generated-work
and host-state variation. The workloads are selected and partly related:
both code subsets come from one corpus. Repeated seeds test repeatability,
not population representativeness. The admission guard was chosen with
historical data visible, uses a fixed query order, and is evaluated on
familiar models and workloads. Public target labels are not a permanently
hidden evaluation set.

\paragraph*{Applicability.}\label{external-validity}
The evidence concerns one synchronous LoRA-GRPO stack on A100 GPUs.
The main comparisons use models of approximately 1.5--3.8 billion
parameters; the larger-model panels test a 7.6-billion-parameter
model from the already represented Qwen family. Incomplete executions
limit the conclusions from that extension. The longest runs
cover 100 steps with validation and checkpoint writing, but do not test
checkpoint restoration or a full training schedule. Broader execution
regimes require their own evidence. The code reward measures syntax and
response shape, not success on executable tests; these runs therefore
do not establish feasibility or learning quality for test-based code
reinforcement learning.

\section{Reproducibility}\label{reproducibility}

RLVRAMBench releases versioned evidence on Hugging Face
\cite{kobza2026benchmark} and separate reproduction software
\cite{kobza2026reproduction}. The package includes raw attempts,
configurations, environment records, exclusion decisions, and a data
dictionary. Reconstruction starts from raw records, checks counts,
seeds, stages, and completed steps, and regenerates tables without a
GPU allocation. Transfer scoring and admission replay likewise run on
central processing units (CPUs); replay records requested observations
and decisions at each budget.

The authors reconstructed the original archive in an isolated environment
without the source project or precomputed input tables. All forty result
files matched after normalizing file-location prefixes. This is an
authors' reconstruction check, not independent external replication.
Version-specific checks and setup instructions accompany the release.

\label{artifact-validity}
Exact GPU rerunning additionally requires the recorded environment,
upstream models, prepared data, and cluster-adapted launchers. Some
historical working-copy changes were not captured as per-run patches,
so their commit IDs do not fully identify the executing source.
Later controls use immutable source copies. This source-history limit
is distinct from reconstructing results from saved measurements.
Model weights and optimizer checkpoint payloads are excluded.
The authors' measurements and software use the MIT license; third-party
materials retain their own terms.

\section{Conclusion}\label{conclusion}

This study measures memory feasibility in a colocated LoRA-GRPO
implementation on A100 GPUs. Releasing generation state enables
completion in some paired cases, and stage measurements reveal training-memory growth hidden
by the overall peak. Individual short tests miss some later margin
crossings even where repeated labels agree. Earlier labels transfer
successfully to the five-step workload panel but admit failures when
copied between GPU counts or to the larger model. The larger-model panels
resolve only failing configurations, leaving recovery of usable settings
unestablished. Fitted memory regression and classification
do not uniformly improve on label copying across held-out families.
Together, these findings support using prior measurements to shortlist
candidates and using stage-complete target tests to check changed
execution conditions. The released evidence makes both useful approvals
and decision errors inspectable.

\section*{Acknowledgment}\phantomsection\label{acknowledgment}
\addcontentsline{toc}{section}{Acknowledgment}

OpenAI Codex \cite{openai2026codex} was used to assist with coding and to refine and polish the manuscript text. The authors are responsible for the code, analyses, and content.
\bibliographystyle{IEEEtran}
\bibliography{references,ieee_access_additions}
\par\noindent\begin{minipage}{\columnwidth}
\phantomsection
\begin{IEEEbiographynophoto}{Ond\v{r}ej Kobza}
is affiliated with the Czech Institute of Informatics, Robotics and Cybernetics, Czech Technical University in Prague, Czech Republic. His work reported in this article concerns GPU-memory feasibility and reproducible benchmarking of large-language-model reinforcement learning.
\end{IEEEbiographynophoto}

\phantomsection
\begin{IEEEbiographynophoto}{Jan \v{S}ediv\'{y}}
is affiliated with the Czech Institute of Informatics, Robotics and Cybernetics, Czech Technical University in Prague, Czech Republic. He supervises the research reported in this article.
\end{IEEEbiographynophoto}
\EOD
\end{minipage}
\end{document}