RLVRAMBench / paper /RLVRAMBench_MDPI.tex
kobzaond's picture
Explain the Figure 1 dash and unresolved telemetry in the caption
00e61d8 verified
Raw History Blame Contribute Delete
162 kB
% Authoritative Electronics revision manuscript. Edit this TeX directly. % Historical evidence is unchanged; revision analyses have separate provenance. %================================================================= \documentclass[electronics,article,submit,moreauthors]{Definitions/mdpi} %================================================================= % MDPI internal commands - do not modify \firstpage{1} \makeatletter \setcounter{page}{\@firstpage} \makeatother \pubvolume{1} \issuenum{1} \articlenumber{0} \pubyear{2026} \copyrightyear{2026} \datereceived{ } \daterevised{ } \dateaccepted{ } \datepublished{ } %================================================================= % Additional packages and commands used by the manuscript \usepackage{textcomp} \usepackage{xurl} \usepackage[section]{placeins} \usepackage{etoolbox} \usepackage{makecell} % vertically centred multi-line table headers \usepackage{collcell} \usepackage{needspace} % Table helpers: centred header cell; right-aligned numbers in a centred block % sized to the widest entry; paired values aligned on their separator; % three-part labels aligned on their slashes. \newcommand{\hd}[1]{\multicolumn{1}{c}{\makecell{#1}}} \newcommand{\numcell}[2]{\makebox[\widthof{#1}][r]{#2}} \newcolumntype{N}[1]{>{\collectcell{\numcell{#1}}}c<{\endcollectcell}} \newcolumntype{L}[1]{>{\raggedright\arraybackslash}p{#1}} \newcommand{\PR}[5]{\makebox[\widthof{#1}][r]{#4}#3\makebox[\widthof{#2}][l]{#5}} \newcommand{\TR}[3]{\makebox[\widthof{failure}][l]{#1} / \makebox[\widthof{failure}][l]{#2} / \makebox[\widthof{failure}][l]{#3}} % Keep floats in the relevant section without forcing half-empty pages at % every subsection. Figures and tables share the main text column. \renewcommand{\topfraction}{0.9} \renewcommand{\bottomfraction}{0.8} \renewcommand{\textfraction}{0.1} \renewcommand{\floatpagefraction}{0.8} \AtBeginEnvironment{table}{\renewcommand{\arraystretch}{1.15}} \captionsetup[figure]{singlelinecheck=false} \captionsetup[table]{singlelinecheck=false} \makeatletter \setlength{\@fptop}{0pt} \setlength{\@fpsep}{12pt} \makeatother \DeclareUnicodeCharacter{2192}{\ensuremath{\rightarrow}} \DeclareUnicodeCharacter{2212}{\ensuremath{-}} \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} \makeatother \setlength{\emergencystretch}{1em} \setlength{\headheight}{20pt} \addtolength{\topmargin}{-8pt} % Requested readability change, kept outside the supplied journal class. \titleformat{\paragraph}[block]{\raggedright\fontsize{10}{10}\selectfont\bfseries}{}{0pt}{} %================================================================= % Full title of the paper \Title{Memory Feasibility in Colocated Language-Model Reinforcement Learning: A Failure-Aware Measurement Study} % Author ORCID IDs \newcommand{\orcidauthorA}{0000-0002-0529-9860} \newcommand{\orcidauthorB}{0000-0003-0626-2303} % Authors \Author{Ond\v{r}ej Kobza *\orcidA{} and Jan \v{S}ediv\'{y} \orcidB{}} % Authors, for metadata in PDF \AuthorNames{Ond\v{r}ej Kobza and Jan \v{S}ediv\'{y}} % Affiliation (single affiliation) \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} % Corresponding author \corres{Correspondence: kobzaond@fel.cvut.cz} % Abstract \abstract{% When language-model reinforcement learning (RL) runs generation and training on shared graphics processing units (GPUs), memory feasibility depends on state kept between execution stages. We study this with Group Relative Policy Optimization in the VERL framework, the vLLM inference engine, and A100 GPUs, mostly with low-rank adaptation (LoRA). We keep failed runs as well as completions within or above a chosen memory limit. RQ1 (configuration controls): moving the trained model's parameters to host memory resolves vLLM startup rejections at the higher tested memory reservation; smaller training micro-batches do not. On A100, a larger micro-batch raises actor-update memory by 3,905 MiB but the whole-run peak by only 7 MiB, and full-parameter training can make the update set the peak. RQ2 (outcome transfer): copying outcome labels across models or GPU counts can approve settings that fail or exceed the limit. RQ3 (run duration): two of twelve one-step screens miss a later limit exceedance, although all four three-run labels agree with 100-step runs. On AMD MI250X with a newer vLLM, 79 of 89 complete labels transfer, but most failures occur after the actor update, and the whole-run peak no longer hides actor growth. We release the measurements and evaluation software as RLVRAMBench.} % Keywords \keyword{colocated execution; failure analysis; GPU memory; Group Relative Policy Optimization; measurement study; reproducibility} %================================================================= \begin{document} \section{Introduction}\label{introduction} \emph{Reinforcement learning} (RL) for language models is training in which the model generates responses, receives rewards for them, and is updated to make better-rewarded responses more likely. The trained model is the \emph{policy}, or \emph{actor}. A \emph{rollout} is a response that the actor generates during training. A \emph{reward} is the score assigned to a rollout; here, rule-based checks on the CPU compute it, for example by checking a final numeric answer. In the setup studied here, a \emph{reference model}, the initial actor kept frozen, also scores the rollouts for a \emph{Kullback--Leibler (KL) penalty}, which discourages the actor from drifting far from its starting behaviour. Each training iteration consists of \emph{execution stages} (\emph{stages}), such as generation, scoring, and the actor update. \emph{Weight synchronization} copies the actor's updated weights, or its updated adapters, into the generation engine (vLLM, introduced below) for the next generation. In \emph{colocated execution}, generation and training run on the same graphics processing units (GPUs), one after the other. Memory demand changes between stages. State kept by the generation engine can stay in GPU memory during training or weight synchronization. A configuration that completes generation may still fail later. A useful measurement must therefore record out-of-memory (OOM) failures as well as the \emph{peaks} (largest sampled memory use) of successful runs. We study \emph{memory feasibility}: whether the requested work completes. The \emph{operating limit} is a chosen ceiling 2,048 MiB below device capacity; this reserve is the \emph{margin}. The limit is a convention, not the physical failure point. In a \emph{within-margin} completion, the run finishes and observed memory stays at or below the operating limit on every GPU. In an \emph{above-margin} completion, the run finishes but exceeds that limit on at least one GPU. A \emph{memory failure} is a run that stops because of a diagnosed GPU-memory error. The primary objective is resource feasibility. A separate iteration-cost panel (a set of planned runs) measures time and host-memory tradeoffs; no experiment evaluates converged model quality. The study uses synchronous Group Relative Policy Optimization (GRPO), an RL method that compares several responses to the same prompt and rewards those better than the group average. Most experiments use low-rank adaptation (LoRA), which trains small added matrices, called adapters, while the original base weights stay frozen. VERL is the RL training framework, and vLLM is the inference engine that VERL uses to generate rollouts. We examine configuration choices in this implementation on A100 GPUs. Additional matched experiments compare LoRA with \emph{full-parameter training}, which updates all actor weights, for the 1.5B and 3B models. They test one change of adaptation method within the same GRPO implementation, rather than assuming that LoRA findings apply unchanged to full-parameter training. The intended reader is a researcher deciding which control to change when a configuration approaches its memory limit. Three controls need not address the same limitation: a smaller training batch, \emph{actor offload} (keeping the actor's parameters in host (CPU) memory and moving them to the GPU only when needed), and a smaller \emph{generation reservation} (the fraction of each GPU's memory that vLLM claims for its weights and cache). Likewise, a profile measured on four GPUs need not justify running the same setting on two. A \emph{screen} is a short test run used to decide whether to run a candidate configuration longer; its value depends on whether it includes the work that may set the peak. Our contribution is an experimental separation of these configuration questions. Comparisons on the same physical GPUs vary each control independently and record cases in which a change turns a failure into a completion, which comparisons of successful-run peaks would miss. They also test \emph{generation-state release}: between generation periods, vLLM moves its weights to host memory and discards its cached attention state. We evaluate predictions and reused \emph{labels} (the recorded outcome of a configuration: within margin, above margin, or memory failure) by the usable settings they recover and the unsuitable settings they approve, not only by overall accuracy. A targeted follow-up fixes predictions before execution and tests whether fitted baselines add value beyond simple rules when controls that previously changed together are varied independently. RLVRAMBench releases the measurements and evaluation software; the article does not propose a new predictor or a universal memory benchmark. \subsection{Practical challenges and research questions}\label{research-questions} A whole-run maximum is cheap to collect and directly describes sampled capacity demand. However, it does not show whether an intervention changes actor demand when a larger peak in generation or weight synchronization hides it. Likewise, reusing the label of a donor configuration (an already measured configuration from another setting) avoids another experiment on the target, and a screen of one training step reduces collection time. These shortcuts are plausible and economical; we do not claim that their prevalence in production has been measured. Their failure modes motivate three questions: changing the wrong control can leave startup blocked, copying a label can approve an unsuitable target, and stopping early can miss a later operation that sets the limit. \begin{itemize} \tightlist \item \textbf{RQ1 --- Configuration controls:} How do offload, state release, batching, and generation reservation affect completion and stage-level memory demand? This identifies which measured limitation an intervention actually addresses. \item \textbf{RQ2 --- Outcomes and transfer:} How well do reused labels and fixed predictors identify within-margin settings when the execution setting changes? This tests whether skipping measurements leads to wrong approvals or to rejected usable settings. \item \textbf{RQ3 --- Execution schedule:} How well do labels from short and longer runs agree when validation and checkpoint writing are included? This determines what evidence a screen gives about the intended work. \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. Among these training systems, DeepSpeed-Chat combines training and inference optimizations \cite{yao2023deepspeedchat}; HybridFlow redistributes actor state between these stages \cite{sheng2024hybridflow}; and RLHFuse merges work within and across stages \cite{zhong2024rlhfuse}. ReaL searches for plans that reallocate parameters across devices \cite{mei2024realhf}. These systems change execution to improve efficiency; our study instead measures configuration outcomes within one execution design. Memory management also changes what stays resident between stages. vLLM stores cached attention state from earlier tokens in blocks \cite{kwon2023pagedattention}. Its Sleep Mode can move weights to host memory or discard cached state \cite{vllm2026sleepmode}. Hydra-RLHF, a memory-saving RLHF method, shares base weights across selectable adapters to reduce policy-training memory \cite{santacroce2023hydra}. Zhou et al.\ study memory use in the RLHF frameworks DeepSpeed-Chat and ColossalChat, covering LoRA, retained state, and the release of unused cache from the framework's memory manager, or \emph{allocator} \cite{zhou2024rlhfmemory}. They show that a control on training memory can leave the overall peak unchanged when inference sets that peak. Our contribution builds on this observation with controlled GRPO experiments. Independently varied offload and reservation expose changes in completion. Same-device comparisons check stage-level effects. \emph{Frozen} predictions (recorded before the target runs were executed) test decisions on combinations absent from the original configuration levels (fixed bundles of settings, defined in the experimental protocol). The vLLM weight offload and cache discard studied here is a different intervention from releasing unused PyTorch allocator cache. In particular, Zhou et al.\ examine allocator fragmentation by comparing reserved and allocated memory and execution with or without preceding inference. Our stage traces are external to the allocator, so they cannot attribute the observed excess to fragmentation: retained live weights, cache capacity, communication buffers, and allocator state can all contribute. The additional evidence here is the controlled change in completion and stage demand, and the decision errors when measurements are reused. \subsection{Memory estimation and configuration decisions}\label{failure-aware-configuration-measurement} Analytical estimators predict memory before training. DNNMem, a memory estimator for deep neural networks, accounts for the computation graph and framework runtime, motivated in part by jobs that fail for lack of GPU memory \cite{gao2020dnnmem}. Its accounting includes tensor lifetimes and allocator reservation, so retained runtime state is not a new consideration introduced by our study. LLMem, a memory estimator for fine-tuning large language models, 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 judge a plan's feasibility \cite{mei2024realhf}. Accounting by components and taking the maximum over stages thus have direct precedents. These estimators use model and execution information. Label transfer instead reuses measured outcomes from a specified source setting. DeepSpeed, a training library, documents estimators that similarly separate parameter, gradient, and optimizer-state requirements under its Zero Redundancy Optimizer (ZeRO) sharding and offload choices \cite{deepspeed2026memory}. Such component budgets are useful references, but they do not by themselves measure colocated generation, weight synchronization, and training. SLO-Guard, a configuration tuner, includes crashes when tuning standalone vLLM serving under service-level objectives, such as response-time targets \cite{lysenstoen2026sloguard}. Here, failures may occur during generation, updates, or weight synchronization. We compare fixed rules for approving configurations, including empirical memory regression and a learned classifier, and keep failed attempts alongside completed peaks. The measured objective is completion and margin compliance, not service latency or an optimized search strategy. We also run the released LLMem estimator against independently measured fine-tuning of OPT models in its native ColossalAI setting (Section~\ref{native-estimator-method}). This gives a numerical external reference without assigning an unsupported VERL prediction to LLMem. The fixed empirical baselines remain the methods evaluated on colocated RL targets; their comparison does not show superiority to LLMem, DNNMem, or ReaL on those targets. Table~\ref{tab:prior-scope} summarizes these differences in scope. \begin{table}[!htbp] \centering \caption{Different questions addressed by related memory analyses. The last column describes the contribution used for comparison, not a claim that an unlisted capability is absent.}\label{tab:prior-scope} \footnotesize \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}L{0.18\linewidth}L{0.31\linewidth}L{0.45\linewidth}@{}} \toprule Approach & Execution and quantity & Relation to this study \\ \midrule Zhou et al.\ \cite{zhou2024rlhfmemory} & DeepSpeed-Chat/ColossalChat; allocated and reserved memory across RLHF stages & Closest prior characterization: LoRA, retained allocator state, and peaks set by inference. Here, matched interventions record changes from failure to completion. \\ \addlinespace[3pt] DNNMem \cite{gao2020dnnmem} & DNN memory estimation informed by the graph and the framework & Predicts demand before a target run. Our empirical label-transfer tests ask whether the available evidence supports approving a changed target. \\ \addlinespace[3pt] LLMem \cite{kim2024llmem} & Distributed fine-tuning of decoder models; predicted GPU peak & We validate its released estimator numerically in native training; mapping it to colocated LoRA training with Fully Sharded Data Parallel (FSDP) and vLLM remains unsupported. \\ \addlinespace[3pt] ReaL \cite{mei2024realhf} & RLHF function calls and parameter placements; static and active memory & Estimates feasibility while searching reallocation plans. Taking the maximum over stages is prior work; this paper tests controlled outcomes. \\ \addlinespace[3pt] DeepSpeed accounting \cite{deepspeed2026memory} & Model-state memory under ZeRO and offload choices & Explicit component budgets motivate capacity planning; our outcome also includes generation admission and state retained across stages. \\ \addlinespace[3pt] RLVRAMBench & Synchronous colocated GRPO, mainly LoRA with a full-training extension; completion, margin, and stage traces & Combines independent controls, failed attempts, matched stage contrasts, and evaluation of fixed configuration decisions, with auditable artifacts. \\ \bottomrule \end{tabular*} \end{table} Asynchronous systems give state different lifetimes: AReaL, an asynchronous RL system, separates generation from training and lets their progress differ \cite{fu2025areal}. Queues, policy versions, and overlapping work then change what is in GPU memory at the same time. This difference motivates a study of state lifetimes, but it gives no evidence that our reservation thresholds or our synchronous release cycle transfer unchanged. Other empirical RL work evaluates learning quality rather than resources. For example, Zeng et al.\ evaluate similarity-guided state attention, a method for visual control policies, for robustness and generalization on the DMControl-GB benchmark \cite{zeng2027stateattention}. That learning-quality objective is distinct from the completion and memory-margin outcomes measured here. \section{Study setting and measurements}\label{rlvrambench} This section defines the execution, outcome labels, and comparisons recorded in RLVRAMBench. The experiments use allocations of two or four A100 GPUs with 40 GB of memory each. Table~\ref{tab:terms} summarizes the key terms. \begin{table}[!htbp] \centering \caption{Key terms used in this article.}\label{tab:terms} \footnotesize \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}>{\raggedright\arraybackslash}p{0.27\linewidth}>{\raggedright\arraybackslash}p{0.67\linewidth}@{}} \toprule Term & Meaning in this article \\ \midrule Actor & The language model being trained. \\ \addlinespace[1pt] Rollout & A response that the actor generates during training. \\ \addlinespace[1pt] Reference model & The initial actor, kept frozen; with LoRA, the actor's base model with adapters disabled. Its scores feed a KL penalty that keeps the actor close to its starting behaviour. With full-parameter training, it is a separate copy. \\ \addlinespace[1pt] Colocated execution & Generation and training run on the same GPUs, one after the other. \\ \addlinespace[1pt] Execution stage & One part of a training iteration: initialization, generation, log-probability scoring, actor update, weight synchronization, validation, or checkpoint writing. \\ \addlinespace[1pt] Weight synchronization & Copying the actor's updated weights, or its updated adapters, into vLLM so that the next generation uses them. \\ \addlinespace[1pt] Generation reservation & The fraction of each GPU's memory that vLLM claims for its weights and key--value (KV) cache. \\ \addlinespace[1pt] Actor offload & Keeping the actor's parameters in host (CPU) memory and moving them to the GPU only when needed. \\ \addlinespace[1pt] Generation-state release & Between generation periods, moving vLLM's weights to host memory and discarding its KV cache. Resident mode keeps both on the GPU. \\ \addlinespace[1pt] Startup rejection & vLLM refuses to start because the free GPU memory at initialization is less than the requested generation reservation. \\ \addlinespace[1pt] Memory feasibility & Whether the requested work completes. \\ \addlinespace[1pt] Whole-run peak / stage peak & The largest sampled per-GPU memory over a whole run (all GPUs and sampled times) / during one marked stage. \\ \addlinespace[1pt] Operating limit and margin & A chosen ceiling 2,048 MiB below device capacity (38,912 MiB here); this reserve is the margin. The limit is a convention, not the physical failure point. \\ \addlinespace[1pt] Within-margin / above-margin completion & The run finishes all requested work, and every sampled per-GPU memory value is at or below the operating limit (within margin) or some value exceeds it (above margin). \\ \addlinespace[1pt] Memory failure & A run that stops because of a diagnosed GPU-memory error: an out-of-memory (OOM) allocation error or a startup rejection. \\ \addlinespace[1pt] Workload, case, configuration & Task data with its length limits, responses per prompt, and global batch; a workload combined with a model, GPU count, and requested duration and operation schedule; the memory and batching settings tested within a case. \\ \addlinespace[1pt] Three-state label & The label of a configuration from three runs with different seeds: within margin, above margin, or memory failure. It is unresolved if any of its three slots lacks an eligible outcome. \\ \addlinespace[1pt] Eligible outcome & A completed run or a diagnosed memory failure, with all required records. Other attempts are ineligible. \\ \addlinespace[1pt] Configuration level (c0--c5) & A fixed bundle of settings that raises the actor micro-batch and the generation reservation together; actor offload is on in c0 and c1 and off above c1. Levels are ordered test settings, not rankings. \\ \addlinespace[1pt] Slot and attempt & A slot is one planned run (one configuration with one seed). An attempt is one actual execution of a slot. \\ \addlinespace[1pt] Same-device block & Runs of one model--workload--seed combination executed on the same physical GPUs in randomized order. \\ \addlinespace[1pt] Screen & A short test run of a candidate configuration, used to decide whether to run it longer. \\ \addlinespace[1pt] Donor (source configuration) & The matched, already measured configuration in a source case (another model, workload, or GPU count) whose label is copied or used to predict a target configuration. \\ \addlinespace[1pt] Label transfer & Copying the measured label of a donor configuration to a target configuration. \\ \addlinespace[1pt] Frozen prediction & A prediction recorded before the target runs were executed. \\ \addlinespace[1pt] Approval, rejection, abstention & Approval predicts that a configuration will complete within margin, that is, a decision to run it. Rejection predicts otherwise. Abstention makes no decision. \\ \addlinespace[1pt] Within-margin recall / approval precision & The fraction of truly within-margin configurations that a method approves / the fraction of approvals that are truly within margin. \\ \bottomrule \end{tabular*} \end{table} \subsection{Execution and batching}\label{cases-and-configurations} One training iteration, or \emph{training step}, starts with a batch of prompts. The generation workers produce several responses to each prompt, and reward functions score those responses. The actor and the reference model then compute log-probabilities (the logarithms of the probabilities each model assigns to the responses), which the update needs. The actor then updates its adapters. Weight synchronization makes the updated actor available for the next generation period. Scheduled validation generates answers without training, and checkpoint writing saves the training state. The \emph{global batch} is the number of prompts, not generated responses, per training step. For example, the Grade School Math 8K (GSM8K) workload \cite{cobbe2021gsm8k} uses 32 prompts and generates two responses per prompt. It therefore supplies 64 prompt--response sequences to the update. The actor \emph{micro-batch} is the number of such sequences that one GPU processes at once during the actor update. Smaller micro-batches accumulate the update over more pieces without changing the global batch. A separate \emph{log-probability micro-batch} sets how many sequences one GPU processes at once when the actor and the reference model compute log-probabilities. In this LoRA implementation, the reference model is not a separate copy. Reference scoring reuses the actor's frozen base model with its adapters disabled. Rule-based reward functions run on the host processors (CPUs). No learned reward model or \emph{critic} (a model estimating expected returns) occupies GPU memory. The main components that reside in GPU memory are therefore the training state, divided across GPUs, and the generation workers, whose state can remain on the GPUs 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, the \emph{key--value (KV) cache} stores the attention keys and values of previous tokens, so that vLLM can generate later tokens faster. A \emph{workload} specifies the task data, the prompt and response length limits, the number of responses per prompt, and the global batch. A \emph{case} combines that workload with a model, a GPU count, and a requested duration and operation schedule. A \emph{configuration} is the set of memory and micro-batch settings tested within that case. This hierarchy keeps a new random seed distinct from a new workload or a new execution setting. The generation reservation is the requested fraction of device memory assigned to the generation engine alone. It is not a cap on all colocated processes together. Startup diagnostics report the capacity and free memory that the engine sees through CUDA, NVIDIA's GPU programming platform; we keep these values separate from the capacity reported by the NVIDIA Management Library (NVML; see Measurements) used for margin labels. The length limits and the maximum number of active sequences further constrain the engine's work. \emph{Offloading} moves state from GPU memory to host memory. Actor parameter offload and optimizer offload are controls separate from generation-state release. Generation-state release suspends the generation workers between generation periods. Resident mode instead keeps that generation state on the GPUs. Section~\ref{experimental-protocol} specifies the tested settings and how the state is restored. \subsection{Three-state labels}\label{safety-labels-and-units-of-analysis} Each planned \emph{slot} is one planned run: one configuration with one random seed. Each repetition runs in a fresh \emph{process}, a new program execution (also called an \emph{invocation}). A complete configuration label requires an eligible memory outcome for each of the three slots. An \emph{eligible outcome} is a run that either completes the requested work or stops with a diagnosed GPU-memory failure, with the required records (listed below). A diagnosed GPU-memory failure, the memory failure of the Introduction, is either an out-of-memory allocation error or a \emph{startup rejection}: vLLM refuses to start because the free GPU memory at initialization is less than the requested generation reservation. Host-memory exhaustion and other unresolved execution failures are not memory failures and do not supply GPU-memory labels. Memory is reported in mebibytes (MiB, \(2^{20}\) bytes) and gibibytes (GiB, \(2^{30}\) bytes). \emph{Device capacity} is the memory that each GPU reports, here 40,960 MiB. The operating limit defined in the Introduction is therefore 38,912 MiB, 2,048 MiB below each device's reported capacity. We fixed this margin before the experiments; it is a convention, not an estimate of the physical failure point. Each configuration receives a \emph{three-state label}, also called its repeated label: \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} If an eligible slot is missing, the repeated label is \emph{unresolved}. For label predictors, only a within-margin prediction counts as \emph{approval}, that is, a decision to run the configuration. An \emph{approval error} approves a configuration that actually completes above margin or has a memory failure; we count these two errors separately. The released artifact's shorthand \emph{safe} means within-margin completion only. The peak of a configuration is the maximum over sampled times, GPUs, and its repetitions. Runtime is the mean over completed repetitions. The highest configuration level (an ordered setting bundle, defined in the experimental protocol) observed within margin 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} Each comparison task gives a method the settings of a \emph{target} configuration and the measurements from a specified source case. The method predicts the target's three-state label; the target measurements are used only for scoring. In \emph{label transfer}, the donor-copy baseline copies the outcome of the matched configuration in the source case, called the \emph{donor} or \emph{source configuration}, to the target. Comparisons change the model, workload, GPU count, or requested duration while holding the other specified settings fixed. Cases are kept whole: another seed of the target, or a supporting control run on the target, is not permitted as donor evidence. Scoring reports three-state accuracy together with two approval rates. \emph{Within-margin recall} is the fraction of within-margin targets that a method approves. \emph{Approval precision} is the fraction of approvals whose targets are within margin. These rates are accompanied by counts of approved memory failures, approved margin violations, and rejected within-margin settings. A rate with an empty denominator is undefined. In \emph{budgeted admission}, a method may also request screens of target configurations. A decision rule approves, rejects, or abstains. \emph{Rejection} predicts that the configuration is not within margin. \emph{Abstention} withholds approval without asserting failure. Separate evaluation runs, not the screens, give the labels against which the decisions are scored (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 the rules that keep source and target inputs separate. \subsection{Measurements}\label{measurements} Each process 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. \emph{External sampling}, a separate process that reads GPU memory from outside the training processes, uses NVML, which reports memory use and utilization for each whole GPU, at 100 ms intervals. Host-side \emph{stage markers} record which execution stage is running, including initialization, scheduled validation, and checkpoint writing. Each memory sample receives the current marker. The markers do not synchronize the GPUs. A sample is therefore assigned to a stage by the observed time interval of that stage, not by the lifetime of each allocation. Unmarked intervals are recorded as idle or unknown. \emph{Allocator traces} record PyTorch tensor allocations and the memory that the allocator (PyTorch's GPU memory manager) retains. A \emph{stage peak} is the maximum per-GPU NVML reading during that stage's marked interval. It measures total device memory, including state retained by other components, not only memory allocated by the active component. A \emph{whole-run peak} is the peak over the whole run, across all GPUs and all sampled times. Comparisons of whole-run peaks use completed runs only: the partial maximum of a failed run is not its completed-run peak. A stage \emph{contrast}, the difference in a stage peak between two conditions, can include a run that fails later only when the compared stage finishes in both conditions. Interrupted or absent stages are recorded as missing, not as 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 length of every sequence actually generated. The \emph{standard code} and \emph{longer-prompt code} subsets are taken from opposite ends of the same CodeContests list ordered by prompt length; they are not independent datasets. Data preparation uses Qwen tokenizers, whereas each run filters prompts with the tokenizer of its own model. A matched workload therefore 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. It does not execute the generated program or use the CodeContests correctness tests. These functions provide the rewards needed to run 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 one actual execution of a slot's runner, not merely a queued job. We distinguish setup errors, diagnosed memory failures, and other or unresolved noncompletion. We identify the failure stage from the logs and traces. An allocator error alone does not show that the failure was caused by \emph{fragmentation}, in which free memory is split into pieces too small to use. Eligibility requires a trial record (the record of the slot's settings and outcome), an environment record, an execution log, a stage trace, and per-GPU measurements. Completion also requires a successful exit and evidence that the requested final work was done. A run with a nonzero exit status enters the memory analysis only if it has a diagnosed memory failure. Other attempts are \emph{ineligible}; they keep their status and the reason for exclusion. Early failures and external-only controls (runs with NVML sampling only) can lack allocator traces; their remaining evidence determines eligibility. Historical repairs repeated unchanged scientific settings after setup errors or after some later noncompletions. After documented exclusions, exactly one eligible outcome is selected per slot; earlier attempts remain in the attempt ledger (the complete record of all attempts). Repeated seeds are separate slots, not retries. The result sections report the relevant attempt denominators. Supplementary Section S1 records the repair histories, including one incomplete memory-failure record. The labels are memory outcomes conditional on eligibility, not estimates of how often jobs complete when all causes of failure are counted. \subsection{Experiment planning and selection}\label{experiment-planning-and-selection} Pilot runs developed the setting ranges and instrumentation; later matrices fixed settings and seeds before execution. We restricted the study to standard GRPO after exploratory results with a custom objective. Those observations and the pilots remain archived but do not enter the reported estimates. The original transfer baselines, the stage reanalysis, and the 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 each research question to its comparisons. Measurement controls help interpret the traces; they are not additional target evidence for prediction methods. Several comparisons use \emph{same-device blocks}: sets of runs of one model--workload--seed combination, all executed on the same physical GPUs in randomized order. \begin{table}[!htbp] \centering \caption{How the experiments support the research questions.}\label{tab:design} \small \setlength{\tabcolsep}{3pt} \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}L{0.16\linewidth}L{0.22\linewidth}L{0.28\linewidth}L{0.28\linewidth}@{}} \toprule Question & Comparison & What changes & Primary evidence \\ \midrule RQ1, RQ2 & Independent-control experiment & Actor offload, batch, and reservation varied separately & Matched outcome changes and frozen simple-rule comparisons \\ RQ1 & Release experiment & Generation state released or resident on the same GPUs & Paired completion and completed-run peaks \\ RQ1 & Batch and reservation & Actor micro-batch and generation reservation & Whole-run versus actor-stage contrasts \\ RQ2 & Boundary and transfer & Model, workload, or GPU count & Repeated three-state labels and directional approval errors \\ RQ2 & Prediction baselines & Held-out model family, then larger models on matched allocations & Frozen predictions, approval errors, and paired outcomes \\ RQ2 & Budgeted admission & Available donor evidence and target-screen budget & Within-margin recall and approval errors on separate evaluation seeds \\ Measurement & Sampling and allocator logging & Sampling interval or logging condition & Label agreement, peak differences, and incomplete attempts \\ RQ3 & Paired duration test and earlier duration tests & Requested steps and scheduled operations & Individual and repeated label agreement; later peak growth \\ RQ1--RQ3 & Cross-accelerator replication & AMD MI250X hardware with ROCm (AMD's GPU software) and vLLM~0.25; also Proximal Policy Optimization (PPO) and full-parameter GRPO & Label agreement with A100, failure stages, stage contrasts \\ \bottomrule \end{tabular*} \end{table} \subsection{Hardware and software}\label{hardware-and-software} The RL 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 RL 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 native LLMem comparison uses a separate one-GPU environment, described in Section~\ref{native-estimator-method}. The container used Python 3.12.3, PyTorch 2.10.0, CUDA 12.9, and vLLM 0.18.0. Our VERL version includes measurement instrumentation and documented compatibility repairs. Environment records preserve software versions, source identifiers, the status of the working copy, and the container checksum. Later controls use immutable copies of the source code; Section~\ref{reproducibility} states the limitation of the historical source records. \subsection{Training setup and configuration levels}\label{training-setup-and-configuration-levels} The historical RL panels 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) splits the actor's training state (parameters, gradients, and optimizer state) across the GPUs of the allocation. The boundary experiment 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. The release experiment and the earlier duration tests also use Qwen2.5-1.5B-Instruct. Tables omit the instruction-tuned suffix; the text uses Qwen, Phi, and Granite when the size is unambiguous. Adapters of rank 64 and scale parameter alpha 32 (the adapter size and scaling) attach to the selected linear layers, excluding the output head. Training computations and generation use the 16-bit bfloat16 (BF16) format, while the sharded actor parameters and gradient reduction use 32-bit floating point (FP32). The difference between stored 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. The KL penalty for departing from the reference model enters 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 log-probability scoring by the actor and the reference model. \begin{table}[!htbp] \centering \caption{Workload settings for the boundary and batch/reservation experiments.}\label{tab:workloads} \footnotesize \setlength{\tabcolsep}{3pt} \renewcommand{\arraystretch}{1.15} {\footnotesize\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lN{0,000}N{0,000}N{0,000}N{000}N{0}N{00}N{0}@{}} \toprule Workload & \hd{Prompt\\cap} & \hd{Response\\cap} & \hd{Model-length\\cap} & \hd{Max\\sequences} & \hd{Rollouts\\per prompt} & \hd{Global\\batch} & \hd{Log-prob.\\micro-batch} \\ \midrule 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 limits the combined prompt and response length; the sequence cap limits the number of generation sequences active at the same time. Each boundary and batch/reservation process performs one training iteration. Supplementary Section S12 reports the sizes of the prepared subsets and the filtering. Other experiments use the settings specified in their own protocols below. These workloads are selected stress cases, not a representative sample of RL training. GSM8K permits longer responses. MATH uses a shorter combined length with a larger global batch. The two code subsets change the prompt lengths within the same dataset. The length and sequence caps affect generation and log-probability scoring, whereas the actor micro-batch affects the work of the actor update. Realized lengths and filtered sample counts, not the caps alone, describe the work actually executed. The settings give controlled contrasts across these cases. They do not establish that the settings suffice for arbitrary context lengths, reward implementations, or data distributions. \begin{table}[!htbp] \centering \caption{Configuration levels used in the boundary experiment. Each level bundles three settings.}\label{tab:levels} \footnotesize \setlength{\tabcolsep}{3pt} \renewcommand{\arraystretch}{1.15} {\footnotesize\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lN{00}N{0.00}c@{}} \toprule Level & \hd{Actor micro-batch\\per GPU} & \hd{Generation\\reservation} & \hd{Actor parameter\\offload} \\ \midrule 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 \emph{configuration levels}, c0--c5. Each level is a fixed bundle of settings. From one level to the next, the actor micro-batch and the generation reservation increase together, and actor parameter offload is disabled above c1. The levels are ordered test settings, not equally spaced values of one variable. The level comparison therefore cannot isolate the effect of an individual control. Optimizer offload is disabled and generation-state release is enabled throughout the boundary experiment. Development runs checked that the selected cases included both within-margin and unsuitable settings. The levels therefore deliberately probe an observed operating range. They are neither theoretical capacity boundaries nor an unbiased grid chosen without prior outcomes. Statements about individual controls rest on the independent-control experiment, not on the ordering c0--c5. \subsection{Experimental coverage}\label{experimental-coverage} Table~\ref{tab:attempts} separates planned slots, actual attempts, and eligible outcomes in the original studies. \begin{table}[!htbp] \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.15} {\footnotesize\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lN{\textbf{000}}N{\textbf{000}}N{\textbf{000}}N{\textbf{00}}N{\textbf{00}}@{}} \toprule Study & \hd{Planned\\slots} & \hd{Recorded\\attempts} & \hd{Completed} & \hd{Memory\\failures} & \hd{Excluded} \\ \midrule Boundary experiment & 216 & 251 & 156 & 60 & 35 \\ Release experiment & 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 duration test (100 steps) & 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 batch-by-logging control adds 24 eligible outcomes from 26 attempts; the budgeted-admission experiment adds 48 from 48. Before the larger-model panels, these studies therefore contain 660 eligible processes from 731 attempts. The later experiments have separate counts of planned slots and eligible outcomes: the larger-model panels (Section~\ref{larger-model-results}), the independent-control experiment, the additional frozen panels, the external LLMem comparison, and the MI250X replication. Sixteen supporting historical screens and observations from abandoned parts of the study 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. Filtering with each model's tokenizer can change which examples reach that batch. Supplementary Section S12 reports these counts and realized lengths and does not treat missing summaries as zero work. \subsection{Transfer between execution settings}\label{transfer-between-models} Each model uses all four workloads and all 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 the workload and level, and they require all three runs to complete for both models. A change of model also changes the architecture, parameter count, and tokenizer. The retrospective workload baseline uses one donor workload's six-level profile to predict the other workloads for the same model; collecting that profile requires eighteen eligible processes. We evaluate every choice of donor workload. Model transfer instead copies the matched label from another model, following the task rules in Section~\ref{benchmark-tasks-and-evaluation}. The four-GPU study keeps one generation worker per GPU, and no worker splits its model across GPUs. Three models, two mathematics workloads, levels c2--c4, and seeds 111--113 give 54 processes. The global batch, the number of rollouts, and the remaining settings are unchanged. We compare its labels with the earlier two-GPU results in both directions. Because GPU count was not randomized within a common experimental period, this comparison is a transfer test, not an isolated causal estimate of adding GPUs. \subsection{Prediction baselines}\label{estimation-methods} We compare three ways to predict a configuration's outcome before running it: copy an earlier label, predict a memory peak and compare it with the limits, or learn the label directly. These are diagnostic baselines for assessing configuration decisions, not proposed prediction methods. Unlike the task-by-task comparisons above, this comparison pools source evidence across cases. The pool contains the 72 boundary configurations and eighteen four-GPU configurations. Each configuration is one observation that combines three eligible seeds. In each of three retrospective tests, all thirty configurations from one model family are withheld, and the other sixty supply the source evidence. No seed, workload, or GPU-count variant of the test family enters the fit. The historical results were public during method design, so withholding a family at fitting time does not make method development blind. The \emph{donor-copy} baseline copies the label of a source configuration with the same workload and configuration level. Among these, it prefers the same GPU count, then the same model family, and then the nearest parameter count; a fixed identifier breaks remaining ties. Target outcomes do not influence the choice of donor. The two fitted methods use size estimates calculated from model metadata and the requested execution settings. These inputs describe the training state, generation memory, and intermediate computations, without target measurements. \emph{Component regression} predicts a peak by learning nonnegative weights for these size estimates. Its fitting target is the maximum peak over three completed repetitions; configurations with a failure supply no numerical peak target. The fitted weights are associations, not measurements of separate physical components. With component regression, a \emph{startup guard} first rejects settings whose resident actor shards plus the requested generation reservation already exceed capacity. For all other settings, the regression compares its predicted peak with capacity and the operating limit to assign a label. Passing the guard alone does not give approval. The \emph{logistic classifier}, a multinomial logistic regression, instead learns a linear score for each outcome class and selects the class with the largest score. It uses failure labels as well as completions. Both fitted methods learn input scaling from fitting data only and use fixed settings without a parameter search. Classifier scores are not calibrated failure probabilities. Supplementary Section S16 gives the eight input definitions, equations, regularization and class weighting, donor selection, and source-record counts. The larger-model replication tests whether the fixed predictors identify usable settings beyond the original model sizes. It crosses Qwen2.5-7B-Instruct \cite{qwen2024qwen257b} and Mistral-7B-Instruct-v0.3 \cite{mistral2024mistral7bv03} with GSM8K, MATH, and longer-prompt code at levels c1--c3 on two or four task GPUs. Mistral adds a model family that was absent from fitting. Three fresh seeds give 36 configurations and 108 planned slots. Each process requests one training step, without validation or checkpoint writing. Runs with both GPU counts share a four-GPU allocation, in a balanced, randomized order, with 384 GiB of host memory. All predictions are frozen. They use the original ninety-configuration fit without refitting. The reports separate c1, which offloads actor parameters, from c2/c3, which keep them on the GPUs. Ten targets lack a donor with the same GPU count; for these, the fixed donor rule keeps its fallback to a two-GPU donor. Supplementary Section S16 also retains two earlier, partly unresolved Qwen-7B panels and their amendments for host memory and recording. The replication does not replace those attempts or their labels. \subsection{Independent-control experiment: separating offload from the other controls}\label{independent-offload-design} This experiment asks whether offload, micro-batch, and generation reservation predict outcomes when varied separately. After the larger-model evaluation, we identified a simple rule that approved only the c1 settings on four GPUs. On those targets, this rule approved the same six within-margin configurations as the classifier, without the classifier's additional approvals. Because c1 combines offload, micro-batch, and reservation, that result does not establish prediction across independently varied controls. To test this limitation, the independent-control experiment runs every combination of actor parameter offload (on or off), actor micro-batches 4 and 8, and generation reservations 0.45 and 0.70. Each model--workload--seed block runs all eight conditions on the same four GPUs in randomized order. Qwen-7B and Mistral-7B use the three larger-model workloads, with three fresh seeds per configuration. Generation-state release remains enabled; it is not the offload control varied here. Each invocation requests one training step, without validation or checkpoint writing. The two fitted predictors keep their original weights. We compare them with simple rules that approve offloaded settings, lower-reservation settings, settings in either group (the \emph{combined rule}), or only the original c1 combination. These rules make approval decisions without assigning three-state labels. The primary prediction comparison asks whether the classifier avoids erroneous approvals at the cost of rejecting usable settings. Separate offload comparisons hold the micro-batch and the generation reservation fixed. Earlier results and inspection of the predictions motivated this targeted design; it is not an independent sample of deployment workloads. Supplementary Sections S16 and S17 give the frozen comparisons and the execution protocol. The predictions remain unchanged after evaluation. The new outcomes test the earlier models; they are not another fitting set. The reservation endpoints have a specific selection history. The lower value, 0.45, was kept from the offloaded configuration level. Before running the independent-control experiment, inspection of the frozen predictions led us to change the upper value from 0.60 to 0.70. This increased the disagreements between the classifier and the combined rule from three to seven, covering both model families. The design is therefore a targeted test of differing decisions, not a blind choice of endpoints. Two endpoints alone cannot locate a transition or determine outcomes at intermediate values. \subsection{Budgeted admission with separate evaluation runs}\label{prospective-admission} This experiment asks how much existing measurements help in budgeted admission, when only a fixed number of target screens may be requested. 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 changed length limits and responses per prompt, with five training steps and final validation and checkpoint writing. The experiment therefore tests a compound change of workload and schedule, not one factor. Supplementary Section S9 records the complete target settings. Each of the twelve target configurations has four fresh processes. Seed 141 supplies the only screen that a rule may request, and this screen runs 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 the donor evidence (the source configuration whose label is copied). Target settings, source records, seed roles, screening order, rules, and budgets were frozen. Physical collection order is randomized with a recorded seed. We compare three simple rules. \emph{Source copy}, the admission version of donor copy, initially approves each target whose donor completed within margin. 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 with no decision on any target and uses no donor measurements. After a requested screen, each rule approves the candidate if that process completes and no sampled per-GPU peak exceeds the operating limit. Completion above the limit or a diagnosed memory failure causes rejection; unresolved noncompletion causes abstention. Unscreened candidates keep the rule's initial decision. Offline replay of the collected records 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 work that has not started is not charged. Supplementary Section S9 specifies the frozen limits on setup repairs, the bounds for missing outcomes, and the abstention and stopping rules. \emph{Incremental accounting} counts only target attempts and assumes that donor evidence already exists. \emph{Cold-start accounting} also adds the nine historical donor attempts per case for the transfer rules (source copy and the headroom guard). Running all screening and evaluation runs of this experiment is a research cost, not freely available method evidence. Attempts differ in work: donors execute one step and targets execute 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} These experiments ask whether keeping generation state limits completion, and how micro-batch and reservation change memory. The release experiment runs both conditions in turn on the same node and GPUs. Half of the pairs run release first and half run resident first. Before each period, combined idle memory across the two GPUs must be below 2,048 MiB. Eligible pairs require both records and identical GPU identities. This combined check differs from the later per-GPU check. Release uses vLLM sleep mode level 1 to suspend the generation workers after initialization or generation. Weights move to host memory, and the KV cache is discarded. The measured LoRA implementation restores the weights before weight synchronization; this \emph{restore} is also called vLLM ``wake-up''. It copies base weights when first needed and adapter updates thereafter, then restores cache capacity before generation resumes. Resident mode disables this cycle. Both conditions keep the adapters separate from the base weights, use the same weight-synchronization mechanism, and perform one training iteration without validation or checkpoints. A \emph{base configuration} is the set of shared settings before release is varied. Section~\ref{releasing-generation-state-changes-completion} gives all six base configurations. Each uses three seeds. Within each model--algorithm--workload group, the selection script ranks earlier within-margin configurations that had release enabled by their observed peak. It selects the highest-peak candidate and, for Qwen-3B, also the lowest-peak candidate. Restricting this selection to standard GRPO gives the six rows reported here. Thus the selected base configurations (the anchors, labelled ``near-boundary'' and ``safe-margin'') reflect prior observations, not an analytical derivation of reservation fractions. Their reservations (0.30, 0.35, 0.65, and 0.70) belong to base configurations with different workloads, offload states, and micro-batches; they do not form a reservation sweep. The comparison is release versus resident within each row. Differences between rows cannot identify a reservation effect. An untested reservation requires a new execution, not interpolation of the labels. A separate batch/reservation \emph{factorial experiment} runs every combination of actor micro-batches 8 and 16 with generation reservations 0.60 and 0.70, across three models, four workloads, and three seeds. Each model--workload--seed block contains these four conditions. A \emph{factor contrast} is the difference caused by changing one factor, averaged over both settings of the other factor. An \emph{interaction} measures how much that difference depends on the setting of 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 peak comparisons require both runs to complete, and factorial peak contrasts require all four. The retrospective reanalysis of stage peaks uses the same blocks. To test whether these contrasts persist when placement and order are controlled, a separate \emph{same-device replication} covers all twelve model--workload cases. Each of three fresh seeds receives all four conditions, run as fresh processes on the same two GPUs. Condition order is randomized and balanced across the 36 allocations. \emph{Full instrumentation}, which adds allocator tracing to external memory sampling, is used throughout. The primary comparisons are the micro-batch effect on the actor-stage peak and the reservation effect on the whole-run peak. We also compare micro-batch effects at both levels to test whether the overall maximum hides training growth. Numerical contrasts require four validated completions, whereas outcome reporting keeps every planned slot. Supplementary Section S17 gives the order, deadlines, and rules for incomplete blocks. The batch-by-logging control described below addresses a different question: whether added allocator instrumentation changes the micro-batch contrast. \subsection{Measurement controls}\label{follow-up-controls-and-transfer-tests} These controls ask whether the sampling interval and allocator logging change 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, we resample the 10 ms traces at intervals of 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 keeps only NVML sampling and stage markers. The full-instrumentation condition additionally synchronizes GPU work before each traced worker operation, resets the allocator's peak counters, and records allocator statistics when the operation returns, without another synchronization. Waiting for outstanding GPU work can change timing and stage attribution. The orders are balanced across allocations, with an idle-device check before each period. Outcomes use all eligible pairs; numerical contrasts require the relevant completed measurements. The comparison concerns added allocator logging, not the cost of all measurement activity. The targeted \emph{batch-by-logging control} additionally runs every combination of micro-batches eight and sixteen with the two logging conditions in each allocation. Phi/GSM8K and Qwen/longer-prompt code each receive three seed blocks, with the generation reservation fixed at 0.60. The control asks whether the micro-batch effect persists without allocator tracing and how its size changes under full instrumentation. Supplementary Section S6 gives the order, a predeclared 512 MiB diagnostic, and the bounded amendment to the plan made after an initial noncompletion. All original attempts remain in the inventory. \subsection{Testing one-step screens over longer runs}\label{testing-one-step-screens-over-longer-runs} This experiment asks whether one-step screen outcomes hold over longer runs. The paired duration test covers Phi and Granite on GSM8K and MATH, with three seeds per case. Each allocation runs a fresh one-step screen and a separate 100-step process. Settings were fixed before evaluation: actor micro-batch sixteen, and generation reservation 0.65 for Phi and 0.75 for Granite. Both run lengths use the same filtered training split and include final validation and checkpoint writing. The long schedule also validates before training and every twenty steps, and writes checkpoints every 25 steps. Runs start without restoring a checkpoint. Every long run stays in the comparison regardless of its screen's outcome. Completion requires all scheduled work. We compare repeated labels, individual pairs, and later memory growth relative to each long run's own first-step peak. Supplementary Section S14 gives the full schedules and the separate earlier Qwen duration tests with forty and 100 steps. \subsection{Additional adaptation, reservation, and cost controls}\label{revision-control-method} These panels ask whether the findings depend on LoRA adaptation and on the coarse tested grid, and what each memory control costs. Four additional frozen panels (the adaptation panel with its no-KL control, the reservation-sensitivity panel, the release-sensitivity panel, and the iteration-cost panel) address these questions. They keep all planned slots, allow no automatic replacements, and keep unresolved noncompletion separate from diagnosed memory failure. Fresh processes run in randomized same-device blocks. The matrix, source, model and data hashes, order, and resource caps were fixed before execution. Table~\ref{tab:revision-design} lists the designs. Each configuration has three fresh seeds. These finite grids are selected follow-ups, not samples from a deployment population. \begin{table}[!htbp] \centering \caption{Additional RL panels. Counts are planned slots. The external LLMem validation is a separate training experiment with 24 pairs.} \label{tab:revision-design} \footnotesize \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}L{.17\linewidth}L{.56\linewidth}rr@{}} \toprule Panel & Independently compared factors & Steps & Runs \\ \midrule Adaptation & Qwen 1.5B/3B; GSM8K/longer-prompt code; LoRA rank 64/full; actor offload on/off; reservation 0.45/0.65 & 5 & 96 \\ No-KL control (adaptation panel) & Qwen 3B/GSM8K; LoRA/full; actor offload on/off; reservation 0.65; KL disabled & 5 & 12 \\ Reservation sensitivity & Qwen 7B/Mistral 7B; GSM8K/longer-prompt code; actor offload on/off; six reservations 0.45--0.70 in 0.05 increments & 1 & 144 \\ Release sensitivity & Two original GSM8K anchors; release/resident; three reservations around each anchor & 1 & 36 \\ Iteration cost & Qwen 7B/GSM8K and Mistral 7B/longer-prompt code; common anchor and three single-factor contrasts & 20 & 24 \\ \bottomrule \end{tabular*} \end{table} The adaptation panel uses four GPUs and actor micro-batch 4. Full training sets the adapter rank to zero. A \emph{parameter inventory}, a list of actor parameters and their trainable status, verifies that all actor parameters are trainable and that no adapter parameters exist. In native execution, which keeps the KL penalty, full training adds a separate reference model, whereas LoRA reuses its frozen base weights as the reference. The full-versus-LoRA contrast therefore also includes changes in reference layout and in weight synchronization. The separate twelve-run \emph{no-KL control} removes reference scoring from both modes by disabling the KL penalty. It changes the objective and is not pooled with the native-KL panel. It does not remove the difference between full-weight and adapter synchronization, or make the resulting training trajectories identical. Three earlier two-step compatibility runs remain development-only. The reservation-sensitivity panel holds micro-batch 8, four GPUs, and state release fixed. Twelve complete order sequences balance each condition's position and its neighbours across blocks. The original predictor coefficients and admission rules remain unchanged; ``low reservation'' in the fixed rule still means exactly 0.45. Intermediate fractions are scored separately from the endpoints. Only tested transitions are reported; no untested fraction receives a label by interpolation. The release-sensitivity panel separately reproduces two two-GPU anchors: Qwen-1.5B/GSM8K at 0.70 and Qwen-3B/GSM8K at 0.65. It tests each original fraction minus 0.10, the original value, and the original plus 0.05. Other workload controls stay fixed within each anchor. The common anchor of the iteration-cost panel offloads actor parameters, uses generation reservation 0.45, and releases generation state. Its contrasts each change one setting: they disable offload, raise the reservation to 0.70, or keep generation state resident. All use micro-batch 8, four GPUs, external-only instrumentation, and twenty updates without validation or checkpoint writing. Updates 1--2 are reported separately; the primary timing window is updates 3--20. Token rates use the realized prompt-plus-response work, which can differ after training. The iteration-cost runs are not paired with one-step screens. The reservation-sensitivity panel is a separate experiment with other seeds and full instrumentation. Only jointly completed runs enter paired cost comparisons. A sampler reads the job's control group (cgroup) once per second and separates anonymous host memory, not backed by files, from file cache charged to the job. Task-execution and outer-allocation GPU-hours are alternative cost views; the release-sensitivity panel uses two task GPUs inside a four-GPU allocation. None of these short panels evaluates convergence or final model quality. \subsection{External estimator validation}\label{native-estimator-method} This experiment asks how well the released LLMem estimator predicts measured training memory in a setting it supports. We run LLMem's unmodified released \texttt{size\_estimator.py} at commit \texttt{3d289b4}. We use the authors' overlay on commit \texttt{d4fb7bf} of ColossalAI, a library for distributed training of large models. The isolated environment uses PyTorch 2.0.1+cu117, Transformers 4.29.2, and ColossalAI 0.3.0. Training uses 16-bit floating point (FP16) with Gemini, ColossalAI's manager that places model state in GPU or host memory, together with gradient checkpointing and HybridAdam, ColossalAI's Adam optimizer that can run on the CPU and the GPU. This environment does not alter the RL runtime. OPT-125M and OPT-1.3B each use batch sizes 1 and 4 and sequence lengths 256 and 512, with three seeds per cell. This gives 24 prediction/measurement pairs, each run on one A100. Prediction follows the released procedure for initialization and output profiling, including its measured baseline memory term. Measurement then uses a fresh process on the same device and completes three optimizer steps. Controlled synthetic token batches without padding fix the input shapes. The Transformers OPT implementation is used without the authors' additional per-layer printing probes. Consequently, this is a native training comparison, not an exact reproduction of the published accuracy table based on Alpaca. A 10-ms NVML trace measures whole-device memory during training; the allocator's allocated and reserved peaks are kept as separate quantities. The source, dependencies, checkpoint hashes, matrix, and device identity were fixed before the formal runs. One earlier setup failure and one development pair are kept outside the formal denominator. This comparison evaluates neither generation nor the complete RL loop. Likewise, the model and placement assumptions of the released ReaL estimator do not supply a validated mapping for our setup: an FSDP actor that trains only adapters, a shared reference, and resident vLLM state. We therefore report unsupported colocated targets explicitly, rather than treating a missing external prediction as a rejection or as zero memory. \subsection{Cross-accelerator replication}\label{cross-accelerator-method} This experiment asks which observations depend on the A100 stack. A separate panel replays configurations on AMD Instinct MI250X accelerators of the LUMI supercomputer \cite{lumi2026}. Each device is one graphics compute die (GCD), one of the two dies of a module, which acts as a separate GPU and reports 65,520 MiB. The operating limit is again 2,048 MiB below capacity, that is, 63,472 MiB. The software also changes: ROCm 7.2.3 (AMD's GPU software platform), PyTorch 2.11.0, vLLM 0.25.1, and the VERL 0.9.0 release in a fixed container (SHA-256 recorded per run). The A100 study instead used an instrumented development checkout with vLLM 0.18.0. The panel therefore tests transfer to a different hardware \emph{and} software stack, not a hardware effect in isolation. VERL settings match the A100 runs: LoRA rank 64 and alpha 32, the KL penalty in the actor loss, and the same micro-batches, generation reservations, offload switches, length limits, and seeds. A sampler reads the driver counter of used device memory for each allocated GCD every 100 ms. Like NVML's used memory, this counter includes allocations from every process. A start-up hook, code loaded when the program starts, writes VERL's own stage timers in the same marker-file format as the A100 instrumentation. Two further hook patches are compatibility repairs that do not change memory settings. First, in-memory LoRA tensors use vLLM's unstacked weight mapper. Second, a chat-template probe, used only by multi-turn loops, tolerates Mistral's role check. Allocator traces are not recorded. The frozen matrix has five parts and 462 planned slots, all with fresh processes and three seeds per configuration: (i) every A100 GSM8K/MATH configuration of the boundary experiment, the factorial experiment, the four-GPU study, and the release experiment, with the A100 seeds (90 configurations); (ii) the GSM8K/MATH part of the larger-model replication (24 configurations); (iii) an MI250X reservation sweep of the generation reservation from 0.30 to 0.95 at fixed c3 settings for Qwen-3B and Phi on GSM8K; (iv) GRPO-LoRA, Proximal Policy Optimization (PPO), and full-parameter GRPO at c2/c3 for Qwen-1.5B and Qwen-3B on GSM8K; and (v) one-step screens and separate 40-step runs of the configurations of the earlier A100 40-step tests. PPO uses generalized advantage estimation with a full-parameter value model (the critic) on the same devices. The Parameter-Efficient Fine-Tuning (PEFT) library, which provides LoRA, could not wrap VERL's token-classification critic in this stack. Code workloads are excluded because their A100 preparation and reward were not available. Jobs share nodes with other allocations, and runs are not randomized within same-device blocks. Outcome rules and failure diagnosis follow Section~\ref{failure-taxonomy}. Four \emph{runtime amendments} handle defects in the experiment harness (the scripts that launch and record runs) and in our own planning. Each amendment is a written record, made before the affected slots were rerun, that documents a defect and lists the slots that run again. Three amendments concern non-memory failures in jobs sharing a node: a weight-synchronization socket path shared through the host's \texttt{/tmp}, missing shared-memory segments at vLLM start-up, and a port race, which an amendment's own faulty port setting made systematic. The fourth amendment covers seven slots. Six 40-step runs reached step 30 without any memory failure and were stopped by a planned time limit of 120 minutes that was too short; they ran again with 240 minutes and unchanged settings. One larger-model slot lost its node; Slurm restarted it under the same job identifier, and the restarted execution failed while reading a partly written kernel cache, so the slot ran again in a fresh directory. Only slots with logged evidence of these defects run again. Diagnosed memory outcomes are never rerun, and every attempt and execution remains in the attempt ledger. \subsection{Statistics}\label{statistics} This subsection states how results are summarized. The analysis is descriptive. We report configuration counts, per-case results, and differences within matched allocations. An \emph{equal-case mean} averages per-case values so that each case has the same weight. Repeated seeds test whether execution repeats; they are not new workloads or independent samples from a deployment population. Transfer comparisons keep complete model--workload cases together, following the emphasis on implementation details and on the uncertainty of few runs in reinforcement-learning evaluation \cite{henderson2018matters,agarwal2021precipice}. The main paper emphasizes observed ranges and agreement in direction. The supplement keeps the earlier group-resampling summaries and a sensitivity analysis that gives the two code subsets half weight each. These calculations describe how the results depend on the selected cases. They do not provide bounds on population risk, and they do not compensate for the small number of distinct workloads. \section{Results}\label{results} We first separate the effects of memory controls, then evaluate configuration decisions, and finally compare short and longer executions. \subsection{RQ1: Configuration controls and memory demand}\label{memory-control-results} These comparisons separate three effects of changing a control: allowing a run to start and complete, changing its whole-run peak, and changing memory demand within one stage. \subsubsection{Offload and reservation jointly determine the tested boundary}\label{independent-offload-results} The independent-control experiment varies actor offload and the generation reservation separately on four GPUs to test whether each decides completion. All 144 planned slots produce eligible outcomes, with no retry or replacement. Of these, 108 complete within margin and 36 have memory failures. Every configuration has three agreeing repetitions. Table~\ref{tab:offload-outcomes} summarizes the resulting 48 labels. The pattern holds for both models, all three workloads, and both micro-batch sizes. \begin{table}[!htbp] \centering\small \caption{Outcomes of the independent-control experiment on four GPUs. Each cell contains twelve configurations: two models, three workloads, and two actor micro-batch sizes. Each configuration has three eligible repetitions.} \label{tab:offload-outcomes} \setlength{\tabcolsep}{4pt} {\small\setlength{\tabcolsep}{4pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lcc@{}} \toprule Actor parameters & Reservation 0.45 & Reservation 0.70 \\ \midrule Kept on GPUs & 12 within margin & 12 memory failures \\ Offloaded to host & 12 within margin & 12 within margin \\ \bottomrule \end{tabular*}} \end{table} All failures are startup rejections at vLLM initialization. They are not failed actor updates or evidence that an allocation reached physical capacity. Reducing the actor micro-batch from eight to four does not remove this startup constraint. With micro-batch and reservation fixed, enabling offload changes memory failure to within-margin completion in all 36 higher-reservation pairs. Both conditions complete in the 36 lower-reservation pairs. Thus, at the higher reservation, only offloaded configurations complete in the tested grid. At the lower reservation, offload is not required for the observed completions. At reservation 0.45, offload reduces the whole-run peak in every matched pair. The equal-case mean reductions are 3,226 MiB at micro-batch four and 3,223 MiB at micro-batch eight; individual reductions range from 1,868 to 4,296 MiB. Reductions of the generation-stage peak are much larger, about 12,750 MiB at either micro-batch. With offload enabled, the whole-run peak occurs during the marked weight-synchronization interval in all 36 lower-reservation runs. The larger generation-stage reduction therefore does not produce an equally large whole-run reduction. Supplementary Section S17 gives the stage contrasts and seed ranges. At reservation 0.70, no run with the actor kept on the GPUs completes, so no completed-run peak reduction can be estimated. Its completion change must not be replaced by comparing partial peaks of failed runs. In short, offload decides completion at the higher reservation; at the lower one, it lowers the whole-run peak far less than the generation-stage peak. \subsubsection{Sensitivity to intermediate reservation values}\label{reservation-sensitivity-results} The reservation-sensitivity panel asks how outcomes change between the two reservation endpoints. Among 144 planned slots, the panel yields 111 within-margin completions, eleven above-margin completions, 21 memory failures, and one unresolved telemetry record. Figure~\ref{fig:reservation-sensitivity} shows all three seeds per cell. All 72 offloaded invocations complete within margin. Without actor offload, Qwen-7B/GSM8K completes within margin through 0.60, exceeds the margin at 0.65, and fails at 0.70. The other three model/workload cases complete within margin through 0.55. At 0.60 their eligible runs exceed the margin, and at 0.65 and 0.70 they fail. Mistral/longer-prompt code at 0.60 has only two eligible above-margin runs and one invalid trace, so its three-state label remains unresolved. \begin{figure}[!htbp] \centering \includegraphics[width=\linewidth]{figures/electronics_reservation_sensitivity.pdf} \caption{Reservation sensitivity with actor micro-batch 8 and generation-state release enabled. Cells give within-margin/above-margin/memory-failure counts. The dash in the grey Mistral/long-code cell at reservation 0.60 without offload marks one unresolved run with invalid memory telemetry, excluded from the displayed counts; the other two runs completed above margin. Other colours show the worst observed outcome. Only tested reservations are shown.}\label{fig:reservation-sensitivity} \end{figure} Eighteen failures are explicit startup rejections. The three Qwen-7B/longer-prompt-code failures at 0.65 instead occur during generation, after vLLM has started successfully. Among 72 matched offload pairs, enabling offload changes 21 memory failures and eleven above-margin completions to within-margin completion. In 39 pairs, both complete within margin; one pair remains unresolved. These observations locate tested transitions, not a continuous threshold valid for other batches, contexts, engines, or execution durations. In short, offloaded runs stay within margin at every tested reservation; without offload, outcomes move from within margin to above margin to failure as the reservation rises. \subsubsection{Releasing generation state changes completion}\label{releasing-generation-state-changes-completion} The release experiment tests whether keeping generation state on the GPUs limits completion, by running each base configuration with release (vLLM sleep mode) and in resident mode on the same GPUs. In the eighteen same-GPU pairs, release completes and resident mode fails in nine; both modes complete in the other nine. No pair completes only in resident mode. Table~\ref{tab:release} gives every base configuration (shared settings before release is varied). Of the resident failures, six occur during weight synchronization and three during the actor update. A comparison requiring two completed peaks would drop these pairs, although they contain the main completion result. \begin{table}[!htbp] \centering \caption{All base configurations in the release experiment. 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.15} {\footnotesize\setlength{\tabcolsep}{2pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}llcN{000}N{0}N{000}ccc@{}} \toprule Model & Workload & \hd{Prompt /\\response\\cap} & \hd{Max.\\sequences} & \hd{Rollouts /\\prompt} & \hd{Global\\batch} & \hd{Actor /\\log-prob.\\micro-batch} & \hd{Reservation;\\actor\\offload} & \hd{Completed} \\ \midrule Qwen2.5-1.5B & GSM8K & \PR{0,000}{0,000}{ / }{1,024}{2,048} & 64 & 2 & 32 & \PR{00}{0}{ / }{16}{8} & \PR{0.00}{yes}{; }{0.70}{no} & \PR{0}{0}{ / }{3}{3} \\ Qwen2.5-1.5B & MATH & \PR{0,000}{0,000}{ / }{512}{512} & 128 & 2 & 64 & \PR{00}{0}{ / }{16}{8} & \PR{0.00}{yes}{; }{0.70}{no} & \PR{0}{0}{ / }{3}{0} \\ \addlinespace[3pt] Qwen2.5-3B & GSM8K & \PR{0,000}{0,000}{ / }{1,024}{2,048} & 64 & 2 & 32 & \PR{00}{0}{ / }{1}{4} & \PR{0.00}{yes}{; }{0.30}{yes} & \PR{0}{0}{ / }{3}{3} \\ \addlinespace[3pt] Qwen2.5-3B & GSM8K & \PR{0,000}{0,000}{ / }{256}{1,024} & 256 & 5 & 128 & \PR{00}{0}{ / }{16}{8} & \PR{0.00}{yes}{; }{0.65}{no} & \PR{0}{0}{ / }{3}{0} \\ Qwen2.5-3B & MATH & \PR{0,000}{0,000}{ / }{1,792}{1,024} & 256 & 5 & 128 & \PR{00}{0}{ / }{16}{8} & \PR{0.00}{yes}{; }{0.65}{no} & \PR{0}{0}{ / }{3}{0} \\ Qwen2.5-3B & MATH & \PR{0,000}{0,000}{ / }{1,792}{1,024} & 256 & 5 & 128 & \PR{00}{0}{ / }{2}{8} & \PR{0.00}{yes}{; }{0.35}{yes} & \PR{0}{0}{ / }{3}{3} \\ \bottomrule \end{tabular*}} \end{table} In the nine pairs where both modes complete, keeping generation state resident increases the mean peak by 7,061 MiB. This contrast covers 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 keep the order and grouping information. Throughput and latency costs of release were not the objective of this experiment. \paragraph{Sensitivity around the original release anchors.} The release-sensitivity panel retests two original base configurations (anchors) at nearby reservations. Its 36 runs yield seventeen within-margin completions, six above-margin completions, twelve memory failures, and one timeout with unresolved cause. For the Qwen-1.5B/GSM8K anchor, both complete within margin at 0.60. At 0.70, all three resident runs exceed the margin, while all three release runs stay within it. At 0.75, resident mode fails during the actor update in all three seeds. Release completes within margin twice and times out once before a completed update. For the Qwen-3B/GSM8K anchor, all nine resident runs fail: three during the actor update at 0.55 and six during weight synchronization at 0.65/0.70. All nine release runs complete, with within-margin counts of 3/3, 2/3, and 1/3 at the three reservations in increasing order. The six pairs in which both modes complete are all Qwen-1.5B cases. Their resident-minus-release mean peaks are 6,070 MiB at 0.60 and 5,912 MiB at 0.70. Supplementary Section S20 reports every cell and seed range. Failed partial peaks and the timeout do not enter these numerical contrasts. In short, release lets runs complete that fail in resident mode, but it does not guarantee within-margin completion. \subsubsection{Stage-level and overall memory contrasts}\label{the-overall-peak-hides-the-training-batch-effect} The same-device replication of the factorial experiment asks whether the whole-run peak reveals the effects of the actor micro-batch and the generation reservation. It yields 140 validated completions in 35 complete four-condition blocks. The four unresolved outcomes of the one incomplete block stay excluded from continuous contrasts. All twelve cases contribute: Qwen on standard code has two complete blocks, and every other case has three. Of the completed processes, 116 stay within the operating limit and 24 exceed it; all exceedances concern Phi at reservation 0.70. Increasing the actor micro-batch from 8 to 16 raises the actor-stage peak in every complete block. As an equal-case mean, the increase is 3,905 MiB, compared with only 7 MiB in the whole-run peak (Figure~\ref{fig:stage-contrasts} and Table~\ref{tab:factorial}). Individual block contrasts range from 773 to 9,034 MiB, showing the variation behind that average. Case-averaged whole-run contrasts range from \(-37\) to 67 MiB. The actor update sets the whole-run peak in none of the 140 completed traces. Thus, a nearly unchanged whole-run peak can conceal substantial growth during training. \begin{figure}[!htbp] \centering \includegraphics[width=\linewidth]{figures/electronics_stage_contrasts.pdf} \caption{Micro-batch effects in the same-device replication at each reservation. Each point is a seed's batch-16 minus batch-8 contrast; diamonds are case means. Actor-stage and whole-run differences share the same horizontal scale. The four unresolved slots of one block stay outside numerical contrasts; standard-code Qwen therefore has two complete blocks, and the other cases have three.}\label{fig:stage-contrasts} \end{figure} \begin{table}[!htbp] \centering \caption{Same-device micro-batch/reservation replication with fixed full instrumentation. Entries are mean within-block differences in MiB, rounded to the nearest MiB; \(n\) is the number of complete blocks. Batch contrasts compare 16 with 8 sequences per device, averaged over reservations. Reservation contrasts compare 0.70 with 0.60, averaged over batches. The last row weights the twelve case means equally. Supplementary Section S17 keeps per-case ranges and all outcomes.} \label{tab:factorial} \small \setlength{\tabcolsep}{5pt} {\small\setlength{\tabcolsep}{4pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}llN{0}N{0,000}N{\(-00\)}N{0,000}@{}} \toprule Model & Workload & \hd{\(n\)} & \hd{Actor-stage\\batch contrast} & \hd{Whole-run\\batch contrast} & \hd{Whole-run\\reservation contrast} \\ \midrule Granite & GSM8K & 3 & 1,374 & \(-1\) & 4,081 \\ & MATH & 3 & 1,932 & \(-37\) & 4,083 \\ & Standard code & 3 & 2,067 & \(-18\) & 4,072 \\ & Longer-prompt code & 3 & 3,460 & 7 & 4,080 \\ \addlinespace[3pt] Phi & GSM8K & 3 & 2,424 & 15 & 4,088 \\ & MATH & 3 & 4,635 & \(-9\) & 4,094 \\ & Standard code & 3 & 4,915 & 5 & 4,091 \\ & Longer-prompt code & 3 & 8,093 & 18 & 4,091 \\ \addlinespace[3pt] Qwen2.5-3B & GSM8K & 3 & 2,682 & 14 & 4,046 \\ & MATH & 3 & 3,723 & 28 & 4,004 \\ & Standard code & 2 & 4,942 & 67 & 3,960 \\ & Longer-prompt code & 3 & 6,608 & 1 & 4,033 \\ \midrule Equal-case mean & & & 3,905 & 7 & 4,060 \\ \bottomrule \end{tabular*}} \end{table} Increasing the generation reservation instead raises the whole-run peak by an equal-case mean of 4,060 MiB. This is close to the additional tenth of device capacity requested. The replication controls physical placement and randomizes execution order, while keeping instrumentation fixed. The batch-by-logging control (Figure~\ref{fig:logging}) tests whether the batch contrast persists without allocator tracing. The original factorial experiment, run in separate allocations, showed the same directional pattern: a 3,980 MiB actor-stage batch contrast but a \(-31\) MiB whole-run contrast. All 144 of its processes completed, with 24 above the limit. Those descriptive results, including allocated-tensor measurements, remain in Supplementary Section S3. In short, the micro-batch mainly changes actor-stage memory, whereas the generation reservation changes the whole-run peak. \begin{figure}[!htbp] \centering \pandocbounded{\includegraphics[width=\linewidth,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 mark additional allocations after initial noncompletion. The points are observed block effects, not confidence intervals. ``Full logging'' in the legend denotes full instrumentation. Section~\ref{effect-of-allocator-instrumentation} reports the attempt history.}\label{fig:logging} \end{figure} \subsubsection{Sensitivity to measurement}\label{effect-of-allocator-instrumentation} Three measurement controls test whether allocator logging or the sampling interval changes outcomes or stage contrasts. In the instrumentation control, completion and margin labels agree between the external-only and full-instrumentation conditions in the 36 eligible pairs, although stage contrasts can change. Both conditions complete in thirty pairs. 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 configuration. Four additional external-only attempts have no eligible counterpart: two have setup errors and two time out with unresolved cause. The timeouts prevent a claim of complete agreement across all attempts; Supplementary Section S1 reports the missing-outcome range. 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; medians per configuration range from \(-176\) to 400 MiB. Qwen/MATH c4 fails before the actor update. These stage differences motivated the direct batch-by-logging control (Supplementary Section S2). The batch-by-logging control gives six complete blocks and 24 within-margin completions among 26 attempts. Two initial full-instrumentation processes, both first in order, time out without a diagnosed memory failure; the remaining conditions of their blocks do not start. A bounded amendment adds one unchanged allocation per incomplete block and keeps both original noncompletions (Supplementary Section S6). Actor-stage batch contrasts are positive under external-only measurement in every complete block, with case means of 1,966 MiB for Phi/GSM8K and 6,430 MiB for Qwen/longer-prompt code (Figure~\ref{fig:logging}). Full instrumentation gives 2,287 and 7,059 MiB, respectively. The logging interaction (change in the batch contrast under full instrumentation) ranges from \(-220\) to 1,054 MiB; three of six blocks exceed the 512 MiB diagnostic threshold in absolute value. Whole-run batch contrasts stay between \(-160\) and 132 MiB. The actor-stage increase therefore persists without allocator logging, but its measured size changes. Responses are not identical between conditions, and the initial failures also differ in order, seed, and allocation. The control therefore does not isolate logging from every execution difference. \label{measurement-calibration} In the sampling calibration, all twelve runs complete. Resampling the 10 ms traces at coarser intervals changes neither their observed peaks nor their assigned stages. This supports 100 ms sampling for the sustained peaks in these traces (Supplementary Section S8). In short, neither allocator logging nor the sampling interval changes the labels of the eligible pairs, but allocator logging can change the measured size of stage contrasts. \subsubsection{Full-parameter training changes the stage comparison} \label{full-parameter-results} The adaptation panel and its no-KL control test whether the stage comparison changes when the actor trains all weights instead of LoRA adapters. Of 108 planned slots in the adaptation panel and its no-KL control, 106 complete within margin and pass the measurement checks: 94 of 96 native-KL runs (with the KL penalty) and all twelve no-KL controls. The remaining two processes also exit successfully after five updates, but malformed stage telemetry leaves their resource outcomes unresolved. They are neither replaced nor included in paired numerical contrasts. No eligible run in this panel fails or exceeds the margin, so it does not locate a full-training OOM boundary. Parameter inventories verify that the full-parameter actors (adapter rank zero) train all 1,543,714,304 and 3,085,938,688 parameters, respectively, with no adapters. The corresponding LoRA actors train 73,859,072 and 119,734,272 adapter parameters. All 106 eligible completions have five updates recorded in durable trainer records, with finite recorded actor losses and gradient norms. Figure~\ref{fig:full-parameter} shows the 46 native-KL pairs in which both modes complete, out of 48 planned pairs. As an equal-case mean over model/workload/offload cases, full training increases the actor-stage peak by 13,697 MiB at reservation 0.45 and 13,748 MiB at 0.65. The corresponding whole-run increases are 5,296 and 4,609 MiB. \begin{figure}[!htbp] \centering \includegraphics[width=\linewidth]{figures/electronics_full_parameter_contrasts.pdf} \caption{Full minus LoRA sampled memory peaks in the native-KL panel. Small points are seed pairs; diamonds are case means; fractions give jointly completed/planned pairs. Native full training also changes reference layout and synchronization. Both reservations use the same horizontal scale; the two telemetry-invalid invocations contribute no numerical contrast.}\label{fig:full-parameter} \end{figure} All 47 eligible native-KL LoRA runs reach their whole-run peak during generation. Among the 47 eligible full-training runs, eight reach it during the actor update: five only in that stage and three tied with weight synchronization. These eight runs are all Qwen-3B at reservation 0.45. Thus actor growth can remain hidden, but generation does not always set the whole-run peak after changing adaptation mode. Actor offload lowers the whole-run peak in all 46 jointly completed native-KL offload pairs, but it does not uniformly reduce the actor-stage peak. Supplementary Section S20 gives both contrast types separately. The twelve no-KL controls provide six completed full/LoRA pairs. Their equal-offload-case actor-stage contrast is 17,260 MiB, versus 5,412 MiB for the whole-run peak. A large stage contrast therefore persists when neither mode uses reference scoring. This control has a different objective and still includes different full-weight/adapter synchronization; it is not a pure estimate of the reference model's memory cost or a comparison of learning quality. In short, full training raises actor-stage memory far more than the whole-run peak, and the actor update sometimes sets the whole-run peak. \subsubsection{Measured operating costs}\label{iteration-cost-results} The iteration-cost panel measures each control's time and memory cost against a common anchor. All 24 twenty-update runs complete within margin and pass the completed-work checks, giving eighteen paired comparisons with the common anchor: actor offload on, reservation 0.45, and generation-state release on. Table~\ref{tab:iteration-cost} summarizes updates 3--20. For Mistral/longer-prompt code, disabling actor offload reduces iteration time in all three pairs by 18.3--25.6 s, while increasing the mean whole-run peak by 3,137 MiB. Its paired token-rate ratios are 1.20--1.36. For Qwen/GSM8K, the corresponding time differences change sign across seeds. Weight-synchronization intervals account for much of that variation, with per-run means of 36.8--100.4 s when offload is disabled. These intervals are not isolated measurements of communication kernels. \begin{table}[!htbp] \centering \caption{Alternative minus anchor in the twenty-update iteration-cost panel, three same-device pairs per row. Time is the mean [minimum, maximum] of paired per-run iteration-time differences over updates 3--20, in seconds. Peak is the mean paired whole-run difference in MiB.} \label{tab:iteration-cost} \small \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}llrr@{}} \toprule Model/workload & Alternative & Time difference (s) & Peak difference \\ \midrule Qwen-7B/GSM8K & Offload off & $6.5\ [-21.0,60.4]$ & 4,296 \\ & Reservation 0.70 & $8.2\ [-1.6,27.2]$ & $-1$ \\ & State resident & $-8.3\ [-16.0,3.5]$ & 2,840 \\ \addlinespace[3pt] Mistral-7B/long code & Offload off & $-22.2\ [-25.6,-18.3]$ & 3,137 \\ & Reservation 0.70 & $6.3\ [-3.7,24.9]$ & 385 \\ & State resident & $-6.3\ [-14.9,9.6]$ & 6,118 \\ \bottomrule \end{tabular*} \end{table} Keeping generation state resident increases memory in every timing pair, but its time differences change sign across seeds in both workloads. Increasing the generation reservation likewise gives no consistent speed improvement. Realized response lengths differ slightly: per-run means are 255.7--259.5 tokens for Qwen/GSM8K and 543.8--551.6 for Mistral/code. The artifact keeps token counts, sequence counts, warm-up, stage durations, and normalized rates rather than assuming identical tensors. Anonymous host-memory peaks of the job's cgroup range from 167.5 to 177.0 GiB; charged file-cache peaks range from 52.0 to 165.1 GiB. These are whole-job observations, not actor-owned memory or the incremental cost of offloading alone. The formal follow-up experiments consume 171.74 allocation GPU-hours; development attempts add 1.02 GPU-hours. The iteration-cost panel itself uses 53.62 allocation GPU-hours. Supplementary Section S20 separates these costs from the overlapping GPU-hours counted per task invocation. The measurements support conditional memory/time comparisons, without establishing convergence, full-schedule quality, or a universally fastest control. In short, only disabling offload for Mistral/longer-prompt code consistently saves time, at a memory cost. \subsection{RQ2: Configuration outcomes and prediction}\label{configuration-decision-results} We first test whether frozen predictions identify usable combinations of settings in the independent-control experiment. The remaining comparisons examine label transfer between workloads, models, and GPU counts. \subsubsection{Prediction on independently varied controls}\label{independent-offload-prediction} Do frozen decisions identify within-margin settings when actor offload, micro-batch, and generation reservation vary separately in the independent-control experiment? Table~\ref{tab:offload-prediction} reports the frozen decisions. The combined rule approves a setting if the actor is offloaded or the generation reservation is 0.45. This rule approves every within-margin configuration and no memory failure. Offload alone or the lower reservation alone misses some of them. The logistic classifier approves a subset of the combined rule's settings. All seven preselected disagreements complete within margin: six for Qwen and one for Mistral. The classifier's additional rejections therefore lose usable settings and avoid no approval error. Component regression approves all usable configurations, but it also approves six Mistral configurations that fail when the generation engine initializes. The two fitted methods therefore err in opposite directions. \begin{table}[!htbp] \centering\small \caption{Frozen approval decisions for the 48 configurations of the independent-control experiment. Every label is resolved, and no configuration completes above margin. ``Useful'' means within-margin completion. The original c1-only rule approves only the settings that reproduce c1 and serves as a control.} \label{tab:offload-prediction} \setlength{\tabcolsep}{3pt} {\small\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lN{00}N{0}N{00}@{}} \toprule Method & \hd{Useful\\approved} & \hd{Failure\\approved} & \hd{Useful\\rejected} \\ \midrule Combined rule (offload or lower reservation) & 36 & 0 & 0 \\ Frozen logistic classifier & 29 & 0 & 7 \\ Component regression + guard & 36 & 6 & 0 \\ Offload only & 24 & 0 & 12 \\ Lower reservation only & 24 & 0 & 12 \\ Original c1 only & 6 & 0 & 30 \\ \bottomrule \end{tabular*}} \end{table} Beyond the six configurations that reproduce the original c1 settings, the combined rule also approves all thirty within-margin settings among the 42 newly crossed configurations. This result explains why the earlier comparison of configuration levels cannot establish the classifier's added value. It does not establish that simple rules generally outperform learned predictors. The present grid has a simple observed boundary, uses familiar workloads, and tests only two generation-reservation values. The earlier fitted weights and every contrary result remain unchanged. \paragraph{Frozen predictions at intermediate fractions.} The reservation-sensitivity panel tests the same frozen decisions between the two endpoints. It yields 47 complete three-repeat labels: 37 within margin, three above margin, and seven memory failures. One configuration remains unresolved. Table~\ref{tab:reservation-predictions} separates endpoints from intermediate fractions, without refitting or changing the old rule's exact 0.45 condition. At the endpoints, the combined rule approves all twelve within-margin configurations, and the classifier approves nine. At intermediate fractions, the classifier approves 20 of 25 within-margin configurations, compared with sixteen for the combined rule. Thus the combined rule's perfect endpoint result does not extend across the wider grid. Whether the classifier has a recall advantage depends on the tested fractions. \begin{table}[!htbp] \centering \caption{Frozen decisions on the complete three-repeat labels of the reservation-sensitivity panel. Recovery is approved/eligible within-margin configurations. Failure approvals (approved memory failures) and margin approvals (approved above-margin completions) are separate errors. Endpoints have sixteen eligible labels; intermediate fractions have 31 of 32 planned labels. The excluded target is discussed in the text.} \label{tab:reservation-predictions} \small \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}llrrr@{}} \toprule Fractions & Method & Recovery & Failure approvals & Margin approvals \\ \midrule Endpoints & Combined rule & 12/12 & 0 & 0 \\ & Classifier & 9/12 & 0 & 0 \\ & Regression & 12/12 & 2 & 0 \\ & Offload only & 8/12 & 0 & 0 \\ \addlinespace[3pt] Intermediate & Combined rule & 16/25 & 0 & 0 \\ & Classifier & 20/25 & 0 & 0 \\ & Regression & 25/25 & 2 & 2 \\ & Offload only & 16/25 & 0 & 0 \\ \bottomrule \end{tabular*} \end{table} The classifier's zero approval errors hold only for complete labels. Both fitted methods also approve the unresolved configuration: Mistral on longer-prompt code, without actor offload, at reservation 0.60. Its two eligible repeats already exceed the limit; the combined rule rejects it. Thus an approval by a fitted method is not evidence of within-margin execution. Across all complete labels, regression approves 37/37 within-margin targets, but it also approves four memory failures and two above-margin completions. The external estimator LLMem does not support any of the 48 colocated targets; its native-training accuracy experiment is separate. Supplementary Section S20 and the artifact keep all rules and the results split by model, workload, and offload. \subsubsection{Completion and memory margin}\label{completion-and-memory-safety} The boundary experiment tests every configuration level on each workload for Qwen, Phi, and Granite. Of its 72 configurations, 44 complete within margin, eight complete above it, and twenty have memory failures. 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; Supplementary Section S1 gives the process counts by model. Figure~\ref{fig:boundary} shows where each outcome occurs within the tested configuration levels. In short, most failures occur at generation initialization. \begin{figure}[!htbp] \centering \pandocbounded{\includegraphics[width=\linewidth,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 labels across the boundary experiment. Each cell combines three fresh processes. Within each model, the labels across levels are identical for all workloads, which explains why copying the labels of a donor workload succeeds.}\label{fig:boundary} \end{figure} \subsubsection{Simple lookup and cross-model transfer}\label{model-labels-are-not-interchangeable} Can boundary-experiment labels be copied to another workload or model? Within each model, the three-state labels at all six levels are identical across the four workloads. Copying one donor workload's labels therefore predicts every other workload label correctly: 216 comparisons across twelve donor choices involve 72 distinct targets, not 216 independent observations. This grid does not show that a learned, workload-specific predictor is needed. The labels differ between models. Qwen and Granite complete within margin up to and including c3, whereas Phi does so only up to c2. Table~\ref{tab:model-transfer} shows the consequences of copying them. \begin{table}[!htbp] \centering \caption{Copying labels from a source model to a target model at the primary margin. Each direction compares 24 target configurations. Approval errors are split into memory failures and completions above margin.}\label{tab:model-transfer} \small \setlength{\tabcolsep}{3pt} \renewcommand{\arraystretch}{1.15} {\small\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lN{00}N{00}N{0}N{0}N{0}@{}} \toprule Source $\rightarrow$ target & \hd{Correct\\three-state label} & \hd{Approved} & \hd{Approved:\\memory failure} & \hd{Approved:\\above margin} & \hd{Rejected:\\within margin} \\ \midrule 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 failure. These are four of twelve unsuitable targets (above margin or memory failure), or four of sixteen approvals. The two denominators answer different questions. Qwen and Granite approve the same settings, but their labels differ at c4, where Granite completes above margin and Qwen has a memory failure. The choice of margin matters. With the full device capacity allowed, Qwen and Phi have the same completion boundary. Supplementary Section S15 gives the sensitivity analysis over five thresholds, and Section S7 compares completed-run peaks between models. In short, labels transfer between workloads of one model, but not exactly between models. \subsubsection{Transfer between GPU counts}\label{transfer-between-gpu-counts} Do labels transfer between two and four GPUs? The four-GPU study repeats three configuration levels of the boundary experiment for three models on the two mathematics workloads. On four GPUs, all 54 processes complete. Of these, 48 stay at or below the operating limit, which gives sixteen within-margin configurations out of eighteen (Table~\ref{tab:gpu-transfer}). \begin{table}[!htbp] \centering \caption{Outcomes at the same levels on two and four GPUs. ``Within'' and ``above'' are completed runs at or below and above the operating limit; ``failure'' denotes memory failure.}\label{tab:gpu-transfer} \small \setlength{\tabcolsep}{3pt} \renewcommand{\arraystretch}{1.15} {\small\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lcc@{}} \toprule Model / workload & Two-GPU c2 / c3 / c4 & Four-GPU c2 / c3 / c4 \\ \midrule Granite-3.3-2B / GSM8K & \TR{within}{within}{above} & \TR{within}{within}{within} \\ Granite-3.3-2B / MATH & \TR{within}{within}{above} & \TR{within}{within}{within} \\ Phi-4-mini / GSM8K & \TR{within}{above}{failure} & \TR{within}{within}{above} \\ Phi-4-mini / MATH & \TR{within}{above}{failure} & \TR{within}{within}{above} \\ Qwen2.5-3B / GSM8K & \TR{within}{within}{failure} & \TR{within}{within}{within} \\ Qwen2.5-3B / MATH & \TR{within}{within}{failure} & \TR{within}{within}{within} \\ \bottomrule \end{tabular*}} \end{table} Across the eighteen matched configurations, copying two-GPU labels to four GPUs wrongly rejects six within-margin settings and makes no approval error. Copying in the reverse direction, from four GPUs to two, approves two memory-failing and four above-margin settings. These are six of eight unsuitable targets, or six of sixteen approvals. Only levels c2--c4 were tested, so these results do not establish the four-GPU boundary beyond these levels. Exact label accuracy alone can favor a worse approval rule. A rule that always predicts within-margin completion gets more labels right than source copy, but it approves more memory failures (Supplementary Section S13). A rule that always rejects avoids approval errors, but it approves no within-margin setting. In short, copying from two to four GPUs is conservative; the reverse makes approval errors. \subsubsection{Existing evidence and the cost of new tests}\label{admission-results} How many new target tests does each simple rule need to approve the within-margin settings? The budgeted-admission experiment answers this for four prospective cases. All 48 planned slots give validated outcomes: 32 complete and 16 have memory failures. No slot needed a retry, and none is unresolved. The twelve screens and the 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, the final validation, and checkpoint writing. \begin{table}[!htbp] \centering \caption{Admission results for four prospective cases. Entries under the rules give approved / available within-margin candidates. Budget is the number of requested target attempts per case. At every tested budget, every approval by these rules is within margin.}\label{tab:admission} \small \setlength{\tabcolsep}{5pt} \renewcommand{\arraystretch}{1.15} {\footnotesize\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lccc*{3}{>{\centering\arraybackslash}p{3.6em}}@{}} \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 & \TR{within}{within}{failure} & 2/2 & 1/2 & 1/2 & 2/2 & 2/2 \\ Qwen2.5-3B / MATH & \TR{within}{within}{failure} & 2/2 & 1/2 & 1/2 & 2/2 & 2/2 \\ Phi-4-mini / GSM8K & \TR{within}{above}{failure} & 1/1 & 1/1 & 0/1 & 0/1 & 1/1 \\ Phi-4-mini / MATH & \TR{within}{above}{failure} & 1/1 & 1/1 & 0/1 & 1/1 & 1/1 \\ \bottomrule \end{tabular*}} \end{table} When donor labels are already available, source copy approves all six within-margin candidates without any target test. The headroom guard, which also requires extra room below the operating limit, rejects Qwen c3 on both workloads, lowering the equal-case mean of the four case recalls to 75\% without avoiding an approval error. After one screen per case, the source-copy and guard decisions agree by construction. Their only initial differences, the two Qwen c3 candidates, are both screened first. Direct screening, which uses no donor measurements, approves no candidate before testing. Its equal-case mean recall rises to 25\%, 75\%, and 100\% at budgets of one, two, and three attempts per case. The fixed screening order places the only within-margin candidate of Phi/GSM8K last. All nonempty approval sets have 100\% observed precision. Approving every candidate would also give full recall, but it would admit all four memory-failing and both above-margin candidates. At the first tested common per-case budget giving full recall, the new target attempts total zero for source copy, four for the guard, and twelve for direct screening. The transfer rules also use 36 historical donor attempts, which gives cold-start totals of 36, 40, and 12 at those points. Attempts contain different amounts of work, so these counts do not establish savings in GPU time or an optimal choice of which tests to run. Supplementary Section S10 reports the full panel's collection cost. In short, existing donor labels replaced new target tests in these four cases without an approval error. \subsubsection{Prediction across model families and sizes} \label{estimation-results}\label{larger-model-results} How do the fixed predictors perform on families and sizes outside their fitting data? Two distinct tests expose different errors: withholding one original model family during fitting, and applying the fitted predictors to larger models without refitting. In the family-held-out tests, component regression predicts every Qwen label correctly and reduces Phi's above-margin approvals, but it approves all four memory-failing Granite configurations. The classifier avoids those Granite failures but rejects six within-margin Qwen configurations. The startup guard changes no label. Regression's mean absolute error in the predicted peak ranges from 1.35 to 2.57 GiB across families. It is measured only on configurations with three completions, so it ignores failures. Each held-out family has only thirty configurations sharing workloads and levels, which limits the evidence for choosing a general predictor. The separate larger-model replication resolves 35 of 36 configurations: seven within margin, four above it, and twenty-four with memory failures. A log-retention error leaves one configuration unresolved, although its two eligible repetitions already exceed the limit. All c3 settings fail, on both two and four GPUs. Donor copy and regression approve all seven usable settings, but they also approve twenty and nine failures, respectively. The classifier approves six usable settings without approving a resolved failure. However, it rejects the only usable setting that keeps the actor on the GPUs, and it approves one above-margin setting. All three methods also approve the unresolved setting; because its runs already exceed the limit, this approval cannot be useful. In that replication, all of the classifier's useful approvals are c1 settings, which bundle actor offload, a smaller micro-batch, and a lower generation reservation. This concentration motivated the independent-control experiment; it does not establish general predictive ability. Supplementary Section S16 gives the family-specific predictions, matched GPU-count outcomes, 108 planned replication slots, and costs, and the two earlier, partly unresolved larger-model panels, whose attempts remain part of the evidence. In short, each method made a different kind of error: approving failures or above-margin settings, or rejecting usable settings. \paragraph{External native-training comparison.} This comparison tests the external estimator LLMem in its own native training setting, not our RL stack. All 24 formal LLMem pairs complete and pass the raw-artifact checks. Table~\ref{tab:llmem-native} reports the eight cells, with equal weight per cell. The mean absolute error is 236.6 MiB, and the mean absolute relative error is 5.37\%; every prediction exceeds its measured peak. The errors are 5.95--16.66\% for OPT-125M and 0.43--0.90\% for OPT-1.3B. Within each cell, all three seeds produce identical sampled peaks; this repeatability is not evidence of accuracy on other models. All cells complete well below device capacity, so this panel does not validate prediction of the out-of-memory boundary. \begin{table}[!htbp] \centering \caption{LLMem native-training comparison, three pairs per cell. Peaks are in MiB; relative error is $(\widehat M-M)/M$. These are isolated OPT workloads trained with ColossalAI Gemini, not RLVRAMBench target predictions.} \label{tab:llmem-native} \small \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lrrrrr@{}} \toprule Model & Batch & Length & Predicted & Measured & Error (\%) \\ \midrule OPT-125M & 1 & 256 & 3,632 & 3,428.1 & 5.95 \\ & 1 & 512 & 3,704 & 3,482.1 & 6.37 \\ & 4 & 256 & 3,850 & 3,300.1 & 16.66 \\ & 4 & 512 & 4,172 & 3,740.1 & 11.55 \\ \addlinespace[3pt] OPT-1.3B & 1 & 256 & 20,058 & 19,954.1 & 0.52 \\ & 1 & 512 & 20,130 & 20,018.1 & 0.56 \\ & 4 & 256 & 20,328 & 20,146.1 & 0.90 \\ & 4 & 512 & 20,726 & 20,638.1 & 0.43 \\ \bottomrule \end{tabular*} \end{table} The largest error also shows that assuming memory grows with batch size can mislead. At length 256, the allocator's peak of allocated memory for OPT-125M rises from 1,952 to 2,052 MiB between batches 1 and 4. Over the same change, its peak of reserved memory falls from 2,272 to 2,144 MiB. The NVML peak follows this fall in reserved memory. These measurements document different allocation behavior; they do not identify a unique fragmentation mechanism or justify changing the estimator after observing the error. LLMem's prediction itself runs GPU initialization and profiling. With compiled extensions already cached, the measured initialization and profiling time is approximately 3.0--3.4 s for OPT-125M and 10.3--10.5 s for OPT-1.3B. These times exclude interpreter start-up, imports, and first-time compilation. The experiment therefore provides an external reference in a setting that LLMem supports, while the estimator's end-to-end accuracy for this colocated RL stack remains untested. \subsection{RQ3: Short tests and longer execution}\label{longer-runs-retain-labels-despite-memory-growth} \label{longer-run-validation-on-phi-and-granite} Do short-screen labels agree with longer runs that include validation and checkpoint writing? The paired duration test on Phi and Granite compares twelve fresh one-step screens with separate 100-step runs. All long runs complete. Two screens that individually complete within margin are paired with long runs that complete above margin; both pairs are Granite on MATH. A third short repetition in that case already exceeds the limit, so the three-repeat short-run label for that case is already above margin. Table~\ref{tab:horizon} reports individual outcomes separately from the repeated label, which requires all three repetitions to complete within margin. \begin{table}[!htbp] \centering \caption{One-step and 100-step outcomes, with memory measurements from completed long runs. Later growth is the increase over each long run's own peak in its first training step, not over the separate screen.}\label{tab:horizon} \footnotesize \setlength{\tabcolsep}{3pt} \renewcommand{\arraystretch}{1.15} {\footnotesize\setlength{\tabcolsep}{3pt}% \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lcccN{000}c@{}} \toprule Model / workload & \hd{Screen\\completed;\\within margin} & \hd{Long\\completed;\\within margin} & \hd{Repeated\\labels} & \hd{Mean later\\growth\\(MiB)} & \hd{Mean\\validation /\\checkpoint\\peak (MiB)} \\ \midrule Granite-3.3-2B / GSM8K & 3/3; 3/3 & 3/3; 3/3 & \PR{within}{within}{ → }{within}{within} & 159 & \PR{00,000}{00,000}{ / }{38,443}{13,498} \\ Granite-3.3-2B / MATH & 3/3; 2/3 & 3/3; 0/3 & \PR{within}{within}{ → }{above}{above} & 657 & \PR{00,000}{00,000}{ / }{38,875}{15,039} \\ Phi-4-mini / GSM8K & 3/3; 3/3 & 3/3; 3/3 & \PR{within}{within}{ → }{within}{within} & 115 & \PR{00,000}{00,000}{ / }{37,581}{19,581} \\ Phi-4-mini / MATH & 3/3; 3/3 & 3/3; 3/3 & \PR{within}{within}{ → }{within}{within} & 590 & \PR{00,000}{00,000}{ / }{37,883}{24,620} \\ \bottomrule \end{tabular*}} \end{table} The three initially within-margin cases keep that repeated label. All long runs pass the required training, validation, and checkpoint checks. In short, the repeated labels agree in this test, but two individual screens do not. \paragraph*{Earlier duration tests.} The earlier Qwen duration tests address the same question with other schedules. All eighteen forty-step outcomes agree with their historical screens. The original 100-step extension supplies twelve within-margin completions from fourteen attempts. Two earlier attempts stop during weight synchronization without a diagnosed memory failure; their replacements complete. Mean later growth over the first step is 1,717 MiB in the forty-step completions and 1,925 MiB in the original 100-step completions. Supplementary Sections S1 and S5 keep the distinct schedules, the one MATH regime whose three forty-step runs share a single historical screen, and the complete attempt history. \subsection{Cross-accelerator replication}\label{cross-accelerator-results} This subsection asks which of the preceding observations survive the change to MI250X hardware and its software stack (Section~\ref{cross-accelerator-method}). The 462 planned slots led to 510 started jobs and 511 executions, because Slurm restarted one job after a node failure; together they used 255.5 allocated GCD-hours. Twelve pilots (3.1 GCD-hours) and development smoke tests are outside these counts. Every slot except one has an eligible outcome; the remaining slot ended with a vLLM self-check failure that is not a memory failure. Supplementary Section S21 lists every slot, attempt, and runtime amendment. \paragraph*{Repeated labels mostly transfer, but failure stages do not.} Of the 90 replayed A100 configurations, 89 obtain a complete repeated MI250X label, and 79 of these keep their A100 label (Table~\ref{tab:mi250x-transfer}). The remaining configuration (Phi-4-mini, GSM8K, c5) is unresolved under the three-repetition rule: two of its runs fail in the restore, and the third ended with the non-memory vLLM self-check failure. Its two memory failures remain adverse evidence. Copying the 66 A100 within-margin labels approves no MI250X memory failure and two above-margin settings, and rejects four settings within margin on MI250X. Each of the ten disagreements involves a configuration that exceeds the operating limit or fails on at least one of the two platforms. \begin{table}[!htbp] \centering \caption{Repeated labels of the 90 replayed A100 configurations on MI250X. Each label combines three fresh processes; the operating limit is 2,048 MiB below each device's capacity. Unresolved: fewer than three eligible repetitions.} \label{tab:mi250x-transfer} \small \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}lcccc@{}} \toprule & \multicolumn{4}{c}{MI250X label} \\ \cmidrule(l){2-5} A100 label & Within margin & Above margin & Memory failure & Unresolved \\ \midrule Within margin & 64 & 2 & 0 & 0 \\ Above margin & 3 & 5 & 3 & 0 \\ Memory failure & 1 & 1 & 10 & 1 \\ \bottomrule \end{tabular*} \end{table} The way that unsuitable settings fail changes. Ten configurations fail on both platforms; on A100, eight of them are startup rejections by the generation engine. On MI250X, none is rejected at startup. Their 30 failing processes pass vLLM's startup check and complete generation. They then fail at one of three later points. Most fail after the actor update, in the restore before weight synchronization (20). Others fail during weight synchronization itself (8), and two fail in the actor update itself. Across the replayed grid, no MI250X memory failure is a startup rejection. On MI250X, startup rejection occurs only at generation reservations of 0.90 and above, in the separate MI250X reservation sweep. A screen that stops after initialization would therefore detect these A100 failures but none of their MI250X counterparts. \paragraph*{The overall peak no longer hides actor-stage growth.} In the five model--workload cases of the factorial experiment with all four conditions completed on MI250X, raising the actor micro-batch from 8 to 16 increases the actor-stage peak by an equal-case mean of 2,837 MiB and the whole-run peak by 2,836 MiB. The batch effect is positive in all five cases. On A100, the corresponding same-device replication shows 3,905 MiB in the actor stage versus 7~MiB in the whole-run peak (Table~\ref{tab:factorial}). Raising the generation reservation from 0.60 to 0.70 adds 6,523 MiB, close to one additional tenth of the larger device. The whole-run maximum occurs during the weight-synchronization interval (VERL's timed weight-update call, which on MI250X includes the restore) in 170 of the 228 completed replayed runs, and during generation in the other 58. The traces show why. The restore re-allocates vLLM's full reservation while memory held after the actor update is still on the GPU, so actor growth reaches the overall maximum. Allocator traces were not recorded on MI250X, so this retained memory is inferred from the timing of the device-memory trace and is not attributed to specific allocations. These MI250X runs ran in separate allocations rather than same-device blocks. The practical consequence is stack-dependent. On A100, a small whole-run batch contrast concealed training growth, whereas on this stack the two contrasts coincide. In both cases, the stage trace, not the whole-run peak alone, identifies which control matters. This restore interval is included in the comparison. Across 74 configurations completed on both platforms, the completed-run peak exceeds the requested reservation by a median of 12,059 MiB on MI250X, versus 8,031 MiB on A100. \paragraph*{Larger models, other objectives, and longer runs.} Table~\ref{tab:mi250x-panels} summarizes the remaining panels. With 60\% more device memory, 19 of the 24 7B configurations complete within margin on MI250X, against five on A100. Copying the A100 labels approves none of the MI250X failures but rejects fourteen usable settings, so these labels transfer conservatively but not accurately. All four c3 configurations on two GCDs fail on MI250X, all at the restore after the update. In the MI250X reservation sweep, Qwen-3B completes within margin up to 0.70 and Phi up to 0.60; Phi exceeds the limit at 0.70. Both have memory failures after the update at 0.80 and 0.85, and startup rejections from 0.90. In the objective panel, full-parameter GRPO completes within margin for Qwen-1.5B at c2 and c3; for Qwen-3B it exceeds the limit at c2 and fails at c3. PPO with a full-parameter critic completes within margin for Qwen-1.5B at c2, exceeds the limit at c3, and fails for Qwen-3B at both levels. GRPO-LoRA, in contrast, completes within margin in all four cases. The added critic and full-parameter optimizer state therefore move the tested boundary by one or more levels on this stack. These are one-step memory outcomes without validation, checkpoints, or quality evaluation. In the MI250X duration test, all eighteen one-step/40-step pairs agree in their labels, as do all six repeated configuration labels. Completed long runs exceed their paired screen's peak by a mean of 2,386 MiB (maximum 3,138 MiB), and they stay within margin in every case. \begin{table}[!htbp] \centering \caption{Additional MI250X panels. Labels combine three fresh processes; ``wake-up'' denotes failure during the restore, when vLLM brings its released weights and KV cache back before weight synchronization.} \label{tab:mi250x-panels} \footnotesize \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}L{.30\linewidth}L{.64\linewidth}@{}} \toprule Panel & Repeated outcomes \\ \midrule 7B models (24 configurations) & 19 within margin, 1 above margin, 4 memory failures (all two-GCD c3, wake-up); A100: 5 within margin, 3 above margin, 16 memory failures \\ \addlinespace[3pt] Reservation 0.30--0.95 (Qwen-3B, Phi; GSM8K, c3) & Qwen-3B within margin to 0.70; Phi within margin to 0.60, above margin at 0.70; both fail after the update at 0.80/0.85 and at startup from 0.90 \\ \addlinespace[3pt] GRPO-LoRA / PPO / full GRPO (Qwen 1.5B, 3B; c2, c3) & LoRA: 4/4 within margin. Full: 1.5B within at c2/c3; 3B above margin at c2, failure at c3. PPO: 1.5B within at c2, above margin at c3; 3B failure at c2/c3 \\ \addlinespace[3pt] Duration test: one step vs.\ 40 steps & 18/18 pairs and 6/6 repeated labels agree; mean growth over the paired screen 2,386 MiB \\ \bottomrule \end{tabular*} \end{table} The MI250X results show which earlier conclusions hold on a second stack. Within the replayed grid, three carry over: most repeated labels, the decisive role of the generation reservation, and the agreement of short and longer runs. The independent-control experiment was not replayed. The absolute boundaries, the failure stage, and whether the whole-run peak masks training growth do not carry over. A practitioner who moves between accelerators or vLLM versions should therefore re-screen through weight synchronization and inspect stage traces, rather than reuse an A100 generation-reservation fraction or a check that stops after initialization. \section{Discussion}\label{discussion} \paragraph*{Different failure diagnoses call for different fixes.} Figure~\ref{fig:failure-modes} shows the diagnosed memory failures of the boundary experiment, the release experiment, and the independent-control experiment, counting each invocation once. A startup rejection means that the free GPU memory is below the generation reservation that vLLM requests. A startup rejection need not mean that device capacity is used up. A generation OOM, in contrast, is an allocation error during generation. OOMs during weight synchronization or the actor update occur after other changes in the state held on the GPU. We assign these classes from the error message and its call context. The last stage marker alone does not establish the cause, and it cannot identify memory fragmentation. Inspection of the raw logs further splits the 51 startup failures of the boundary experiment into 48 explicit startup rejections and three CUDA allocation failures while vLLM warms up. All 36 startup failures of the independent-control experiment are explicit startup rejections. \begin{figure}[!htbp] \centering \includegraphics[width=\linewidth]{figures/electronics_failure_modes.pdf} \caption{Diagnosed memory failures by experiment. In the plot labels, ``State release'' denotes the release experiment and ``Independent offload'' the independent-control experiment. Denominators include eligible completions and memory failures. Further excluded attempts are listed in Table~\ref{tab:attempts} and in the attempt inventory. Counts by model, workload, generation reservation, batch, actor offload, and generation-state release are given in the follow-up analysis tables.}\label{fig:failure-modes} \end{figure} \paragraph*{Choose a control that addresses the observed limitation.} The independent-control experiment found two measured ways to complete the larger-model workloads on four GPUs. The first keeps the actor parameters on the GPUs and uses the lower generation reservation. The second uses actor offload with the higher reservation. Reducing the actor micro-batch alone does not repair the observed startup rejection. Actor offload needs host memory and adds transfers between host and GPU, while a lower generation reservation can constrain generation. The reservation-sensitivity panel and the iteration-cost panel examine these tradeoffs for selected configurations. They do not establish a performance ranking over a full training schedule, and they do not show that the same decision rule holds for another implementation. \paragraph*{Inspect stages before interpreting a configuration control.} \label{why-stage-level-measurements-matter} A whole-run peak answers a capacity question, while a stage peak shows where memory demand changes. A peak set during generation or weight synchronization can hide memory growth in the actor update. A small difference in whole-run peak between batch sizes therefore does not establish that larger training batches cost little memory. Paired generation-state release outcomes also show why comparisons limited to pairs of two successful runs can miss the important change, namely whether the run completes at all. \paragraph*{Match the setting before reusing a profile.} \label{what-can-be-transferred-between-configurations} Consider moving Qwen2.5-3B on MATH from four GPUs to two. Copying the four-GPU label would approve configuration level c4, but the recorded two-GPU c4 executions fail. The same archive identifies c3 as a within-margin alternative on two GPUs. This evidence supports shortlisting c3 for a test in the target setting. It does not show that this level is optimal or safe for a longer schedule. The example shows how to use the data: match the execution setting, inspect the evidence behind an approval, and test any change that this evidence does not cover. Predictors should be compared by their useful approvals and by their failure errors and margin errors counted separately, not by label accuracy alone. The added timing comparisons describe short completed workloads. They do not rank configurations by converged training quality or by economic value over a full schedule. \paragraph*{Test predictors where their decisions differ.} Success on bundled settings, such as configuration levels that change several controls together, can hide a simple decision rule. Varying the controls independently separates useful rejections from unnecessary caution. Refitting the predictors on the follow-up outcomes could give a different model. Testing that model on the same outcomes, however, would measure adaptation to known data, not improved transfer. The release therefore keeps the unchanged classifier as a diagnostic baseline. Learned predictors could help when many architectures, continuous length settings, and interacting placement controls make exhaustive measurement expensive and simple rules stop separating outcomes. The reservation-sensitivity panel gives a limited example. In this panel, the classifier recovers more within-margin settings at intermediate reservations than the fixed combined rule (approve offloaded or lower-reservation settings). However, it also approves a configuration whose label is incomplete and whose observed runs exceed the margin. This example does not test the value of learning across deployments. Several factors limit learning here: small and dependent samples, bundled historical controls, failed runs that supply no completed-run peak target, unobserved allocator state, and software changes. An extension would need more independent target cases, calibrated abstention, and evaluation on fresh outcomes. The simple rule's success at the original endpoints (the two tested reservations) is not evidence that learning is generally unnecessary. \paragraph*{Test the intended schedule.} \label{how-to-use-a-short-run-screen} The independent-control experiment establishes that settings can start and complete one training step. The iteration-cost panel runs selected larger-model control settings for longer, but without validation or checkpoint writing. The separate 100-step studies use different configurations. They therefore do not validate every control combination over that duration. A screen should include validation and checkpoint writing when the intended run includes them. For Granite on MATH, the repeated short-run label already exceeded the margin and agreed with the long-run label. This agreement does not establish a universal number of repetitions. Record noncompletion for any cause separately from the memory label, which is defined only for eligible outcomes. Figure~\ref{fig:horizon-agreement} separates individual screen decisions by protocol, model, and workload. \begin{figure}[!htb] \centering \includegraphics[width=\linewidth]{figures/electronics_horizon_agreement.pdf} \caption{Agreement of individual within-margin approval decisions across run lengths, by protocol, model, and workload. Blue denotes agreement; orange denotes disagreement. The two disagreements are completed Granite/MATH runs that exceed the margin, not new OOMs. The panels labelled ``Historical screen'' show the earlier 40-step and 100-step duration tests; ``Paired screen'' shows the paired duration test. These schedules are separate and are not pooled into an accuracy estimate. Extra excluded attempts are kept separately: two in the earlier 100-step test and three in the paired duration test.}\label{fig:horizon-agreement} \end{figure} \Needspace{8\baselineskip} \paragraph*{A practical tuning sequence.} \begin{enumerate} \item Record the exact model, the trainable state (LoRA adapters or full parameters), the device topology (the GPUs and how they are connected), the workload, and the intended training schedule. Rerun the failing configuration with stage markers, and keep the records of unsuccessful attempts. \item If vLLM reports a startup rejection, keep the workload fixed and test either a lower generation reservation or actor offload. In our independent-control experiment, a smaller actor micro-batch did not resolve this startup rejection. \item If memory runs short in the actor update, test a smaller micro-batch while keeping the global batch unchanged. Check which generation state stays on the GPU during the update. \item If memory runs short during weight synchronization, or because generation state stays on the GPU, test the documented order of generation-state release, offload, and restore. Then verify that the next generation still completes. \item Repeat the candidate settings over the intended validation, checkpoint writing, and training schedule. Check host memory as well as every GPU, and record above-margin completion separately from memory failure. \item Compare the remaining candidates on the same completed work, using measured time and resource cost. The elapsed time of a one-step run is dominated by startup, so it does not establish sustained throughput, convergence, or quality. \end{enumerate} \paragraph*{What changes when the execution design changes.} The main generation workers each hold a model replica (no tensor parallelism, so the model is not split across GPUs). Adding workers therefore does not divide the weight memory of that replica. Larger models may need a different parallelism and placement design, not a linear rescaling of these peaks. The measured LoRA setup also shares its frozen actor base weights with the reference model for scoring, uses CPU rewards, and has no learned critic. Table~\ref{tab:applicability} states why these bounds matter. \begin{table}[!htbp] \centering \caption{Limits on extrapolating the measured memory boundaries.}\label{tab:applicability} \small \begin{tabular*}{\linewidth}{@{\extracolsep{\fill}}L{0.25\linewidth}L{0.69\linewidth}@{}} \toprule Changed setting & Reason to remeasure \\ \midrule PPO or additional learned roles & Critic, reward-model, or separate reference-model state, and a different update schedule, change which states are on the GPU at the same time. The one-step MI250X check (Section~\ref{cross-accelerator-results}) covers only a full-parameter critic for 1.5B/3B models. \\ \addlinespace[3pt] Full training beyond the tested extension & Gradients and optimizer states cover the base model; reference layout and weight synchronization also change. The five-update 1.5B/3B extension does not validate larger full-training runs. \\ \addlinespace[3pt] Larger models or contexts & Parameter replicas, activations, and KV-cache capacity scale differently; new sharding or parallelism may be necessary. \\ \addlinespace[3pt] H100, L40S, MI300, or another engine & Capacity, kernels, allocator, cache management, and transfer costs differ. An A100 reservation fraction is not a portable capacity rule. On MI250X with vLLM 0.25, both the failure stage and the stage that sets the peak changed (Section~\ref{cross-accelerator-results}); other accelerators remain untested. \\ \addlinespace[3pt] Asynchronous or disaggregated RL & Overlapping roles, queues, policy versions, and buffers create different state lifetimes. \\ \addlinespace[3pt] Larger clusters & Replica placement, sharding degree, interconnects, and temporary communication buffers change; transfer between two and four GPUs does not validate behavior at cluster scale. \\ \bottomrule \end{tabular*} \end{table} Inspecting how long each role keeps its state on the GPU is a hypothesis worth testing on other systems. The numerical thresholds and the successful control rules, however, remain properties of the measured configurations. The MI250X replication gives one concrete example. With the same VERL settings, a newer vLLM restores its generation state while the actor's memory is still held. Failures and peaks therefore move to the restore and weight synchronization after the update. A screen on a new software stack should therefore run through at least one weight synchronization. \section{Threats to validity}\label{threats-to-validity} \paragraph*{Measurement.}\label{construct-validity} Whether a run completes within margin depends on the chosen operating limit, which is a convention rather than the physical failure point. Memory sampling can miss short transient peaks. Stage markers show when a peak or failure is observed, not where every contributing allocation came from. Whole-run outcomes that agree across logging settings therefore do not establish that stage timings or exact operation-level memory demand are unchanged. Malformed stage-marker records also exclude some otherwise completed invocations from the affected paired analyses. For these invocations, the ledgers keep the successful exit and the completed updates separately from the unresolved memory label. We do not assume that the missing records are random. A later fix that writes markers atomically is archived separately; we did not use it to replace these frozen executions. \paragraph*{Comparisons and selected cases.}\label{internal-and-statistical-validity} Configuration levels change several controls at once. A change of model also changes the architecture, size, tokenizer, and sometimes the filtered examples. Blocks of the original factorial experiment and GPU-count comparisons do not control for the GPU allocation or the period in which runs were executed. The new same-device blocks control placement and run order for their own comparisons, but not retrospectively for those earlier runs. Full instrumentation stays fixed throughout the same-device replication; the batch-by-logging control covers only two cases. Generated responses and host state can still vary. The workloads are selected and partly related: both code subsets come from one corpus. Repeated seeds test repeatability, not whether the cases represent a wider population. We chose the headroom guard while the historical data were visible. It uses a fixed screening order and is evaluated on familiar models and workloads. The public target labels are not a permanently hidden evaluation set. Earlier outcomes motivated the independent-control experiment. Before any new execution, we inspected the frozen predictions and, as a result, raised the upper generation reservation from 0.60 to 0.70 while keeping the lower value of 0.45. This change increased the disagreements between the classifier and the combined rule from three to seven and extended them to both model families (Supplementary Section S17). The complete randomized blocks of this experiment support comparisons within the selected grid. The simple rule's perfect result, however, does not estimate accuracy in deployment and does not validate intermediate reservation values. The reservation-sensitivity panel tests those intermediate fractions directly, with the predictions unchanged. The iteration-cost panel separately runs selected larger-model settings for longer. Neither panel retrospectively turns the earlier grid into a random sample of deployment conditions. \paragraph*{Applicability.}\label{external-validity} The main evidence comes from one synchronous GRPO stack on A100 GPUs. Most experiments use LoRA. The full-parameter extension covers only 1.5B and 3B actors for five updates, without validation or checkpoint writing. Its native-KL comparison also changes the reference-model layout and weight synchronization. The no-KL control removes reference scoring, but it changes the training objective and leaves different weight synchronization work. The main comparisons use models of approximately 1.5--3.8 billion parameters; the larger-model replication adds Qwen and Mistral models of approximately 7.6 and 7.2 billion parameters. Mistral adds a model family. Neither this addition nor further seeds, however, establishes transfer to another GPU type or software stack. The MI250X panel is one such transfer test. It changes the accelerator, capacity, runtime, and vLLM/VERL versions together, so it cannot attribute a difference to the hardware alone. It also replays only GSM8K and MATH settings for one step (40 steps in its duration test), on shared nodes without same-device blocks or allocator traces. Incomplete executions limit which configuration decisions can be scored. The longest runs cover 100 steps with validation and checkpoint writing, but they do not test restoring from a checkpoint or a full training schedule. Broader execution regimes need their own evidence. The code reward checks syntax and response format, not success on executable tests. These runs therefore do not establish feasibility or learning quality for code RL with test-based rewards. \section{Reproducibility}\label{reproducibility} RLVRAMBench releases two items: versioned evidence on Hugging Face \cite{kobza2026benchmark} and separate reproduction software \cite{kobza2026reproduction}. The submission version is pinned by the tag \texttt{electronics-submission-2026-10-23} in both repositories; the same dataset version is available on the Hugging Face main branch. Its release manifest identifies the separate historical A100, independent-offload, A100 follow-up, and MI250X raw-evidence archives and their SHA-256 hashes. The evidence package contains raw attempts, configurations, environment records, exclusion decisions, and a data dictionary. Reconstruction starts from the raw records. It checks counts, seeds, stages, and completed steps, and it regenerates the tables without a GPU allocation. Transfer scoring and admission replay also run on central processing units (CPUs). The replay records the requested observations and the decisions at each budget. Reconstruction checks hide the source project and the precomputed result tables from the analysis process. For the independent-control experiment, the archived execution source regenerates all six outputs from raw evidence moved to a new location. The five tables match byte for byte. The summary differs only in its two directory-location fields, which were validated. Earlier panels keep their own reconstruction checks. Version-specific reports list the inputs, the matched outputs, and the permitted normalization of file paths. The authors performed these checks; they are not an external replication. The follow-up experiments have a separate evidence bundle with file hashes. It covers the four additional frozen RL panels (the adaptation panel with its no-KL control, and the reservation-sensitivity, release-sensitivity, and iteration-cost panels), the development attempts, and the native LLMem comparison. The bundle keeps the frozen execution sources separate from later corrections to data collection. Its CPU verifier reconstructs, in fresh processes, the outcomes, paired contrasts, frozen prediction scores, costs, figure summaries, and generated supplementary tables. A Python audit hook blocks three actions: reading the original evidence and the saved follow-up results, writing to artifact inputs, and opening network connections. The libraries of the author's CPU environment remain accessible. The historical plots in this bundle instead use eight previously audited tables and 105 raw failure logs. This check does not regenerate every historical experiment from raw records, and it is not an independent external replication. The accompanying reconstruction guide records these limits on inputs and environment. \label{artifact-validity} Exact GPU reruns additionally need the recorded software environment, the upstream models, the prepared data, and launch scripts adapted to the cluster. Some historical changes in the working copy were not captured as per-run patches. Their commit IDs therefore do not fully identify the source code that ran. Later controls use immutable copies of the source. This limit on source history is separate from reconstructing results from saved measurements. Model weights and optimizer checkpoint files are not included. The authors' measurements and software use the MIT license; third-party materials keep their own terms. \section{Conclusion}\label{conclusion} In the studied colocated GRPO implementation, different memory controls address different constraints. Independent variation of the controls in the independent-control experiment, which uses LoRA, shows that actor offload resolves startup rejections at the higher tested generation reservation, whereas a smaller training micro-batch does not. Same-device comparisons also show why a whole-run peak is not enough to interpret a control: large stage-level changes can be hidden under a peak set in another stage. The five-update full-parameter extension keeps a large difference between actor-stage and whole-run changes. It also produces settings in which the actor stage sets the whole-run peak. The limiting stage must therefore be measured again when the adaptation mode (LoRA or full-parameter training) changes. The prediction comparisons show why success on bundled settings does not by itself establish added predictive value. At the original endpoints of the independent-control experiment, neither fitted baseline improves on the simple combined rule. The reservation-sensitivity panel shows a different recall tradeoff at intermediate fractions. It also shows a classifier approval whose label is unresolved and which already has adverse margin evidence. Earlier labels can also fail to transfer between GPU counts or models, and individual short screens can miss later margin exceedance. On a second stack, AMD MI250X with ROCm and vLLM 0.25, most repeated labels transfer. Infeasible settings, however, fail later, mostly after the actor update, and actor-stage growth then appears in the whole-run peak. Which stage limits a configuration is thus a property of the execution stack, not only of the model and workload. Together, these findings support a concrete procedure: identify the limiting stage, choose a relevant control, compare approvals against failures and completions, and test the intended execution schedule. RLVRAMBench supplies failure-aware evidence, which keeps failed runs, for those decisions within the measured setting. It does not certify untested configurations. %================================================================= %================================================================= \vspace{6pt} \authorcontributions{Conceptualization, O.K.; methodology, O.K.; software, O.K.; investigation, O.K.; data curation, O.K.; writing---original draft preparation, O.K.; writing---review and editing, O.K. and J.\v{S}.; supervision, J.\v{S}. All authors have read and agreed to the published version of the manuscript.} \funding{This research received no external funding.} \dataavailability{The submission dataset is openly available at \url{https://huggingface.co/datasets/kobzaond/RLVRAMBench} (dataset DOI: \url{https://doi.org/10.57967/hf/10780}; version tag \texttt{electronics-submission-2026-10-23}, also published on the main branch). It contains the curated benchmark tables, A100 and MI250X follow-up results, estimator inputs and outputs, raw-evidence archives, and file-hash manifests. The matching reproduction and analysis code is available at \url{https://github.com/kobzaond/RLVRAMBench-reproduce} under the same version tag. Earlier releases remain separately identified. Model weights and optimizer checkpoints are not included.} \acknowledgments{OpenAI Codex \cite{openai2026codex} and Anthropic's Claude Code were used to assist with programming, experiment orchestration, evidence checks, analysis, and manuscript preparation, including language editing. The authors are responsible for the code, analyses, and content.} \conflictsofinterest{The authors declare no conflicts of interest.} \abbreviations{Abbreviations}{ The following abbreviations are used in this manuscript:\\ \noindent \begin{tabular}{@{}ll} BF16 & bfloat16 16-bit floating-point format\\ cgroup & Linux control group\\ CPU & central processing unit\\ CUDA & NVIDIA's GPU programming platform\\ DNN & deep neural network\\ FP16 & 16-bit floating point\\ FP32 & 32-bit floating point\\ FSDP & Fully Sharded Data Parallel\\ GCD & graphics compute die (one die of an AMD MI250X module)\\ GPU & graphics processing unit\\ GRPO & Group Relative Policy Optimization\\ KL & Kullback--Leibler (divergence)\\ KV cache & key--value cache of the attention layers\\ LoRA & low-rank adaptation\\ MiB/GiB & mebibyte ($2^{20}$ bytes)/gibibyte ($2^{30}$ bytes)\\ NVML & NVIDIA Management Library\\ OOM & out of memory\\ PEFT & Parameter-Efficient Fine-Tuning (library)\\ PPO & Proximal Policy Optimization\\ RL & reinforcement learning\\ RLHF & reinforcement learning from human feedback\\ ROCm & AMD's GPU software platform\\ RQ & research question\\ ZeRO & Zero Redundancy Optimizer \end{tabular} } %================================================================= \begin{adjustwidth}{-\extralength}{0cm} \reftitle{References} \bibliography{references,ieee_access_additions,electronics_revision} \section*{Short Biography of Authors} \bio{}{\textbf{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.} \bio{}{\textbf{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.} \PublishersNote{} \end{adjustwidth} \end{document}
% Authoritative Electronics revision manuscript. Edit this TeX directly.
% Historical evidence is unchanged; revision analyses have separate provenance.
%=================================================================
\documentclass[electronics,article,submit,moreauthors]{Definitions/mdpi}
%=================================================================
% MDPI internal commands - do not modify
\firstpage{1}
\makeatletter
\setcounter{page}{\@firstpage}
\makeatother
\pubvolume{1}
\issuenum{1}
\articlenumber{0}
\pubyear{2026}
\copyrightyear{2026}
\datereceived{ }
\daterevised{ }
\dateaccepted{ }
\datepublished{ }
%=================================================================
% Additional packages and commands used by the manuscript
\usepackage{textcomp}
\usepackage{xurl}
\usepackage[section]{placeins}
\usepackage{etoolbox}
\usepackage{makecell} % vertically centred multi-line table headers
\usepackage{collcell}
\usepackage{needspace}
% Table helpers: centred header cell; right-aligned numbers in a centred block
% sized to the widest entry; paired values aligned on their separator;
% three-part labels aligned on their slashes.
\newcommand{\hd}[1]{\multicolumn{1}{c}{\makecell{#1}}}
\newcommand{\numcell}[2]{\makebox[\widthof{#1}][r]{#2}}
\newcolumntype{N}[1]{>{\collectcell{\numcell{#1}}}c<{\endcollectcell}}
\newcolumntype{L}[1]{>{\raggedright\arraybackslash}p{#1}}
\newcommand{\PR}[5]{\makebox[\widthof{#1}][r]{#4}#3\makebox[\widthof{#2}][l]{#5}}
\newcommand{\TR}[3]{\makebox[\widthof{failure}][l]{#1} / \makebox[\widthof{failure}][l]{#2} / \makebox[\widthof{failure}][l]{#3}}
% Keep floats in the relevant section without forcing half-empty pages at
% every subsection. Figures and tables share the main text column.
\renewcommand{\topfraction}{0.9}
\renewcommand{\bottomfraction}{0.8}
\renewcommand{\textfraction}{0.1}
\renewcommand{\floatpagefraction}{0.8}
\AtBeginEnvironment{table}{\renewcommand{\arraystretch}{1.15}}
\captionsetup[figure]{singlelinecheck=false}
\captionsetup[table]{singlelinecheck=false}
\makeatletter
\setlength{\@fptop}{0pt}
\setlength{\@fpsep}{12pt}
\makeatother
\DeclareUnicodeCharacter{2192}{\ensuremath{\rightarrow}}
\DeclareUnicodeCharacter{2212}{\ensuremath{-}}
\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}
\makeatother
\setlength{\emergencystretch}{1em}
\setlength{\headheight}{20pt}
\addtolength{\topmargin}{-8pt}
% Requested readability change, kept outside the supplied journal class.
\titleformat{\paragraph}[block]{\raggedright\fontsize{10}{10}\selectfont\bfseries}{}{0pt}{}
%=================================================================
% Full title of the paper
\Title{Memory Feasibility in Colocated Language-Model Reinforcement Learning: A Failure-Aware Measurement Study}
% Author ORCID IDs
\newcommand{\orcidauthorA}{0000-0002-0529-9860}
\newcommand{\orcidauthorB}{0000-0003-0626-2303}
% Authors
\Author{Ond\v{r}ej Kobza *\orcidA{} and Jan \v{S}ediv\'{y} \orcidB{}}
% Authors, for metadata in PDF
\AuthorNames{Ond\v{r}ej Kobza and Jan \v{S}ediv\'{y}}
% Affiliation (single affiliation)
\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}
% Corresponding author
\corres{Correspondence: kobzaond@fel.cvut.cz}
% Abstract
\abstract{%
When language-model reinforcement learning (RL) runs generation and
training on shared graphics processing units (GPUs), memory feasibility
depends on state kept between execution stages. We study
this with Group Relative Policy Optimization in the VERL framework, the
vLLM inference engine, and A100 GPUs, mostly with low-rank adaptation
(LoRA). We keep failed runs as well as completions within or above a
chosen memory limit. RQ1 (configuration controls): moving the trained
model's parameters to host memory resolves vLLM startup rejections at