Scheduler-Driven Job Atomization (SJA)

• SJA is a scheduling paradigm that transforms monolithic GPU jobs into self-contained subjobs tailored to dynamically advertised execution gaps.
• It employs a bidirectional scheduler–job protocol where jobs generate safe subjobs based on probabilistic resource profiles and offered time-capacity windows.
• SJA enhances GPU utilization and minimizes overhead by preventing fragmentation, reducing wait times, and avoiding costly mid-run migrations.

Scheduler-Driven Job Atomization (SJA) is a conceptual scheduling paradigm for MIG-enabled GPU clusters in which the scheduler advertises short-term execution gaps and jobs respond only if they can generate a safe, self-contained subjob that fits the offered time-capacity window. Introduced as a concept paper, SJA replaces the treatment of jobs as rigid, indivisible blocks with a bidirectional scheduler–job protocol intended to increase GPU utilization, reduce wait times, and minimize migration overhead by shaping workloads before execution rather than repairing mismatches after admission (Konopa et al., 23 Sep 2025).

1. Motivation: fragmentation, rigidity, and the limits of static admission

SJA is motivated by the observation that modern GPU clusters, especially those built on NVIDIA’s Multi-Instance GPU architecture, still suffer from inefficiencies even when hardware partitioning is available. In the baseline model described by the concept paper, a job typically arrives with a single peak-memory estimate and a runtime estimate, and once admitted it occupies its assigned slice until completion. The paper identifies two distinct forms of waste in this regime: spatial fragmentation, where small pieces of GPU capacity remain unused because no pending job exactly fits them, and temporal fragmentation, where a slice may be idle during parts of a job’s lifetime because the job’s resource usage is not constant (Konopa et al., 23 Sep 2025).

The central diagnosis is that schedulers operate on whole jobs and whole slices, whereas the cluster state is granular and time-varying. Static peak memory estimates intensify this mismatch, producing underutilization, longer queueing delays, and higher rejection rates. The paper therefore frames SJA not as a minor optimization of existing placement heuristics, but as a change in scheduling abstraction: execution opportunities are discovered first, and job structure is adapted to those opportunities afterward.

This framing is especially relevant in multi-tenant settings. The concept paper emphasizes that some jobs need large slices while others could fit into short-lived gaps; under conventional admission, the latter opportunities may remain unusable. SJA is proposed as a mechanism for turning such “holes” into schedulable execution windows without relying on mid-run migration or reactive preemption.

2. Bidirectional protocol and the semantics of the subjob

The core operational idea in SJA is a three-phase loop. First, the scheduler advertises an execution gap characterized by a time window and a slice capacity. Second, jobs inspect the offer and signal interest only if they can safely generate a compatible subjob. Third, if multiple jobs are interested, the scheduler applies its allocation policy—such as fairness, throughput or efficiency, SLA priority, energy or carbon goals, or tenant budgets or tokens—and selects one candidate (Konopa et al., 23 Sep 2025).

The atomic execution unit is the subjob. The paper defines a subjob as a self-contained execution fragment of a parent job, bounded in both time and resource footprint. A subjob may include warm-up, steady-state, or bursty phases, but it is admitted only if the scheduler can ensure that the resource footprint stays within the selected slice throughout the subjob’s lifetime. An important design point is that jobs do not materialize subjob state before selection. Interest signaling is therefore lightweight, while actual subjob construction is deferred until a concrete slot has been awarded.

This protocol preserves scheduler authority while redistributing feasibility analysis. The scheduler is no longer described as solving a large global packing problem over indivisible jobs; rather, it chooses among candidates that are already feasible. In that sense, SJA is interactive but not scheduler-agnostic: jobs participate in opportunity detection, yet policy remains centralized at the admission boundary.

The paper presents this architecture as “correct by construction.” The phrase refers to the fact that a subjob is formed specifically for a known window and is intended to complete within that window. The objective is to avoid speculative execution, state transfer, or later rescue mechanisms.

3. Formal building blocks, probabilistic safety, and admission envelopes

SJA introduces three formal building blocks: the subjob, the Temporal Resource Profile (TRP), and the Functional Memory Profile (FMP). A TRP is a probabilistic description of how a job’s resource demand changes over time; an FMP is a TRP specialized to memory usage. The paper states that TRPs and FMPs may come from profiling, static analysis, or prediction models (Konopa et al., 23 Sep 2025).

Safe admission is expressed probabilistically. Let $M_J(t)$ denote the predicted memory demand of subjob $J$ at time $t$. A subjob is admissible on a slice of capacity $C$ over interval $[0,T]$ if

$$\Pr\!\left( \max_{t \in [0,T]} M_J(t) \leq C \right) \geq 1 - \epsilon,$$

where $\epsilon \in (0,1)$ is the risk tolerance. In the paper’s plain-language interpretation, the probability that the subjob ever exceeds the slice capacity during its execution window must be sufficiently small.

To support slice selection, the concept paper defines a risk-adjusted envelope

$U(t) = Q_{1-\epsilon}[M(t)],$

where $Q_{1-\epsilon}$ is the $(1-\epsilon)$-quantile operator. A scheduler-advertised window is then matched to the smallest available slice capacity $J$0 such that the predicted envelope fits:

$J$1

with $J$2 denoting the set of MIG slice sizes.

The paper adds two practical refinements. First, segmentation should be slack-minimizing with hysteresis: the scheduler should choose the smallest slice that safely covers predicted usage, but it should avoid overly fine fragmentation unless there is a meaningful gain in slack. Second, $J$3 may be smoothed over a short horizon to prevent pathological over-fragmentation caused by brief spikes. These details make clear that SJA is not simply about finer partitioning; it is about controlled atomization under probabilistic safety constraints.

4. Distinction from established scheduling paradigms

SJA is explicitly contrasted with migration and preemption. Migration moves a live GPU process from one slice or device to another during execution and may require transfer of large GPU state such as model weights, optimizer state, and activations. Preemption interrupts a running job and later restarts it, requiring checkpointing or resumption overhead. SJA avoids both by waiting for a subjob boundary and launching only fragments that already fit the target opportunity (Konopa et al., 23 Sep 2025).

The paper also differentiates SJA from several adjacent abstractions. Moldable jobs allow the scheduler to choose a shape at submission time, but the job remains monolithic afterward. Malleable jobs support runtime resizing, but this is still scheduler-driven and often checkpoint-based. Divisible-load theory is presented as useful for offline decomposition, but not for online scheduler–job negotiation. Mesos/Borg-style offers are identified as similar in spirit because resources are advertised, yet they still operate on monolithic tasks and do not use predictive subjob generation. Pollux-like co-adaptation is described as job adaptation to scheduler decisions, but not by atomizing execution into scheduler-directed fragments.

These comparisons address a recurring misconception: SJA is not merely a synonym for reactive elasticity. Its defining feature is that the scheduler advertises fragmented opportunities and the job generates a safe subjob in response. The mismatch is prevented at admission time rather than corrected after execution has already begun.

A second misconception is that SJA guarantees globally optimal schedules. The concept paper does not make that claim. It states that the scheduler focuses on short-term advertised gaps rather than long-horizon optimization, and that this may sacrifice some global optimum. The trade-off is deliberate: local feasibility and low overhead are prioritized over expensive global search.

5. Decentralized extension: JASDA

"JASDA: Introducing Job-Aware Scheduling in Scheduler-Driven Job Atomization" extends SJA from a largely centralized scheduling model toward a fully decentralized negotiation process (Konopa et al., 16 Oct 2025). In the original framing, jobs respond to announced windows and expose feasible subjobs, but the scheduler remains the principal decision-maker. JASDA adds a “variant-bidding” layer in which jobs generate multiple feasible subjob variants, score them locally, and submit them as bids; the scheduler then clears the window by selecting the best compatible subset under a combined job or system objective.

JASDA operates in five phases: window announcement, job-side variant generation, bid submission, scheduler clearing, and commit and advance. The announced window is written as

$J$4

where $J$5 is the MIG slice identifier, $J$6 is the slice memory capacity, $J$7 is the earliest available start time, and $J$8 is the duration of the idle window. Eligibility still depends on probabilistic safety, and the paper explicitly carries over the SJA safety condition

$J$9

The scheduler’s clearing decision is based on a convex combination of job-side and system-side utility. In normalized form,

$t$0

The paper further incorporates age-aware prioritization to reduce starvation and introduces a trust calibration mechanism for jobs that misreport utilities. Reliability is summarized by

$t$1

A notable algorithmic result is that the per-window clearing stage is formulated as a weighted interval scheduling problem. After sorting by end time, the scheduler applies dynamic programming with complexity $t$2 for $t$3. JASDA is therefore presented as locally optimal per window under a sum-based scoring model, but not globally optimal in hindsight. Relative to SJA, its novelty lies less in the safety condition than in the explicit decentralization of variant generation, preference expression, and trust-aware clearing.

6. Benefits, limitations, and broader interpretations

The intended benefits of SJA are stated concretely: higher GPU utilization by filling gaps that would otherwise stay idle, lower queueing delay or wait times because smaller compatible fragments can start sooner, lower rejection rates because a large job can progress through smaller subjobs, reduced overhead because there is no mid-run migration or reactive preemption, better predictability because admission is based on probabilistic resource profiles, and fault isolation and modularity because failures affect only one fragment and the parent job can resume from the last completed piece (Konopa et al., 23 Sep 2025).

The same paper is equally explicit about limitations. Not all workloads are atomizable; tightly coupled HPC simulations or monolithic GPU kernels without safe checkpoint boundaries may not fit the model. Complexity shifts toward jobs and runtimes because atomization logic, checkpoint handling, and predictive profiles must exist somewhere in the software stack. Dependence on TRP or FMP quality is a structural constraint: if predictions are noisy or unstable, admission reliability deteriorates. Granularity tuning is also delicate; overly small subjobs raise coordination overhead, whereas overly large subjobs preserve fragmentation. These caveats are central because SJA is presented as a concept paper rather than a fully validated system.

Two later works broaden the interpretive scope of SJA without erasing its original meaning. "ALLSTaR: Automated LLM-Driven Scheduler Generation and Testing for Intent-Based RAN" does not define GPU subjobs, but it is described as sitting “very close to the spirit of Scheduler-Driven Job Atomization” because it turns the scheduler from a monolithic, vendor-locked function into a modular, swappable unit that can be automatically generated, tested, deployed, and reselected from intent. Its pipeline decomposes scheduler work into document extraction, code synthesis, unit testing, OTA testing, profiling, and intent-driven composition; this suggests a domain-specific form of scheduler lifecycle atomization rather than the gap-filling subjob protocol of canonical SJA (Elkael et al., 23 May 2025).

"SAGA: Workflow-Atomic Scheduling for AI Agent Inference on GPU Clusters" is likewise presented as a close conceptual match rather than a direct use of the term SJA. Its central claim is that agentic inference should be scheduled at the workflow or program level rather than at the level of individual LLM requests. SAGA therefore treats the entire agent workflow as the first-class schedulable unit, using Agent Execution Graphs, session-affinity batching with work stealing, and Agent Fair Share. On a 64-GPU cluster serving SWE-bench coding agents and WebArena browser tasks, it reports a $t$4 geometric-mean reduction in task completion time over vLLM v0.15.1 with prefix caching and affinity routing, $t$5 improvement in GPU memory utilization, and $t$6 SLO attainment under multi-tenant interference, while giving up about $t$7 throughput relative to throughput-maximizing batch scheduling (Guo et al., 1 May 2026). A plausible implication is that SJA’s underlying intuition—matching schedulable structure to time-varying opportunities rather than treating execution as a monolith—extends beyond MIG subjobs into workflow-aware inference and programmable RAN control.

Taken together, these works position SJA as both a specific paradigm for MIG-enabled GPU clusters and a broader reference point for scheduler-centric decomposition. In its narrow sense, SJA denotes scheduler-advertised gaps, job-generated safe subjobs, and correctness-by-construction admission. In a broader comparative sense, it names a family resemblance among systems that move the schedulable boundary away from rigid monolithic jobs and toward modular execution units whose form is shaped by the scheduler’s view of opportunity.