Self-Aware Scheduling in Adaptive Systems

• Self-Aware Scheduling (SAS) is a design pattern that uses runtime introspection, predictive models, and adaptive decision-making to optimize task scheduling.
• It employs a closed-loop process of monitoring, modeling, decision making, and adaptation to meet objectives like performance, cost, and energy efficiency.
• SAS frameworks integrate both analytic methods and machine learning techniques to dynamically allocate resources in diverse environments such as cloud systems, HPC, and LLM inference.

Searching arXiv for the cited papers to ground the article in the current literature. I’m pulling recent and foundational arXiv records on self-aware scheduling across systems, cloud, HPC, datacenter, and LLM inference/generation. Self-Aware Scheduling (SAS) denotes a class of scheduling and resource-management approaches in which decisions are driven by the system’s own monitored runtime state, learned or analytical models, and explicit goals. In the SAPA line of work, self-awareness is the computer system’s ability to monitor, collect and analyze data about its own state of execution (Kinsy et al., 2018). In cloud systems, self-aware management and scheduling refers to continuous monitoring, model maintenance, prediction, and runtime adaptation to satisfy SLAs and other constraints such as cost, energy, and reliability (Iosup et al., 2016). Across later work, the same idea appears in DAG runtimes that learn per-core execution characteristics online (Chen et al., 2020), federated schedulers that infer node responsiveness from local telemetry (Grammenos et al., 2021), adaptive OS schedulers that route workloads to specialized policies (Wang et al., 7 Nov 2025), and LLM systems that explicitly model stochastic demand and hybrid compute-memory cost (Gan et al., 9 Mar 2026). The term also acquired a more specialized meaning in diffusion LLMs, where SAS names a framework for learning the token-unmasking “order of thought” from the model’s own pathwise likelihood (Xu et al., 22 Jun 2026).

1. Conceptual scope and historical development

An early precursor appears in Customer Appeasement Scheduling, which argued that the operating system should become intelligent to distinguish between different processes and allocate resources to those processes which need them most, using process dependencies and interprocess communications to reduce customer-perceived latency (Nikseresht et al., 2010). That formulation introduced “unhappiness” as the delay experienced by a customer request and proposed minimizing system-wide unhappiness rather than optimizing only CPU utilization, throughput, or turnaround time (Nikseresht et al., 2010). This shifted the target of scheduling from generic fairness to explicit user-facing responsiveness.

The later cloud literature broadened the idea from process-level interactivity to runtime self-management. A self-aware cloud application or management system continuously monitors itself and its environment, builds and maintains models of its own behavior and of the environment, analyzes and reasons with these models, and adapts configuration, resource allocation, and scheduling policies at runtime to achieve high-level goals (Iosup et al., 2016). SAPA extended this perspective into architecture, coupling monitoring counters, analyzers, and a reconfiguration manager with heterogeneous reconfigurable cores, self-organizing memory structures, and an adaptive network-on-chip (Kinsy et al., 2018).

Taken together, these works suggest that SAS is better understood as a design pattern than as a single scheduler. In some papers it denotes goal-driven scheduling for cloud and datacenter systems (Iosup et al., 2016); in others it is a concrete runtime policy for task-parallel DAGs (Chen et al., 2020), loop scheduling (Booth et al., 2020), Sensing-as-a-Service (Sun et al., 2023), LLM inference (Gan et al., 9 Mar 2026), or diffusion decoding (Xu et al., 22 Jun 2026). A plausible implication is that the unifying feature is not the resource being scheduled, but the presence of introspection, an explicit self-model, and adaptive decision-making.

2. Common architectural pattern: monitoring, modeling, decision, adaptation

A recurring SAS structure is a closed loop that senses runtime state, updates a compact self-model, selects a scheduling action, and applies that action. SAPA makes this structure explicit: monitoring counters capture processing element, memory and network events; analyzers aggregate runtime data; a reconfiguration manager applies machine learning and control theory; and intelligent execution units enact resource reallocations, task rehearsal, task migrations, and approximation modes (Kinsy et al., 2018). SimAS expresses a similar loop in control-theoretic terms: measurement, simulation-based prediction, DLS selection, and runtime switching of the scheduling method (Mohammed et al., 2019).

Several systems instantiate the self-model as an online performance table or low-rank telemetry representation. The Dynamic Asymmetry Scheduler for DAG applications stores, for each task type, a Performance Trace Table whose entries are indexed by core and resource width; each entry is updated online by the weighted rule

$$updated\_value=[(4 \times old\_value) + 1 \times new\_value)]/5.$$

This lets the runtime learn per-task-type, per-core, per-width execution time under interference, DVFS, and changing asymmetry, and then choose execution place and parallelism accordingly (Chen et al., 2020). Pronto adopts a different representation: each node maintains a streaming PCA model of its own high-dimensional telemetry, projects the latest observation onto the learned subspace, detects spikes, and converts them into a local rejection signal that decides whether the node should accept or reject an incoming job (Grammenos et al., 2021).

Other systems use lightweight, explicitly engineered state abstractions rather than richer learned embeddings. ASA monitors CPU, memory, disk, process, scheduling, and network signals, feeds them into an ensemble centered on XGBoost, aggregates class probabilities with time-weighted probability voting, and then switches to the mapped scheduler through Linux sched_ext (Wang et al., 7 Nov 2025). DSSP maintains histogram-based unloaded subtask response-time distributions at edge nodes and uses them to derive exact task and subtask budgets that can be enforced independently inside each administrative domain (Sun et al., 2023). The adaptive loop scheduler iChunk tracks per-thread completed iterations, a global mean throughput, and a variance proxy $\delta = \epsilon \mu$ to classify threads as low, normal, or high and then doubles or halves chunk size through the divisor $d_i$ (Booth et al., 2020).

3. Objectives, uncertainty models, and decision rules

SAS systems differ sharply in what they optimize, but they share the practice of making the objective explicit and binding the scheduler to that objective through a model. In LLM inference, SageSched minimizes average Time-to-Last-Token (TTLT),

$$\text{Minimize} \quad \frac{1}{N}\sum_{j=1}^N \text{TTLT}_j,$$

under GPU compute and memory limits, batching constraints, autoregressive decoding, and KVCache allocation (Gan et al., 9 Mar 2026). Its distinctive move is to model the true service cost of a request as

$\mathcal{C}(I,O)=\frac{O^2}{2}+IO,$

where $I$ is prompt length and $O$ is random output length, thereby encoding both compute work and memory occupation in a single analytic cost (Gan et al., 9 Mar 2026). Scheduling then operates over a predicted distribution of $\mathcal{C}$, not over a single point estimate.

Given a cost distribution $\mathcal{D}_j$ for job $j$, SageSched uses the Gittins index

$\delta = \epsilon \mu$0

where $\delta = \epsilon \mu$1, and schedules the job with the smallest index, updating indices at bucket boundaries as execution progresses (Gan et al., 9 Mar 2026). This is a particularly explicit form of uncertainty-aware SAS: the scheduler reasons over full cost distributions, not only means, and over a hybrid compute-memory bottleneck rather than a single resource (Gan et al., 9 Mar 2026).

Other SAS formulations expose different objective structures. In goal-oriented semantic communication, effect-aware scheduling maximizes the expected discounted sum of CPT-based total Grade of Effectiveness (GoE) under a query cost constraint (Agheli et al., 9 Mar 2025). GoE for attribute $\delta = \epsilon \mu$2 is

$\delta = \epsilon \mu$3

and in the simulations is instantiated as $\delta = \epsilon \mu$4, coupling usefulness and freshness directly (Agheli et al., 9 Mar 2025). DSSP uses tail-latency SLOs and derives exact task budgets from query fanout through

$\delta = \epsilon \mu$5

then computes subtask queuing budgets from measured unloaded response-time distributions and enforces them through subtask-budget-aware EDFQ (Sun et al., 2023).

The cloud survey makes clear that SAS objectives are often multi-objective rather than single-metric. The literature it organizes spans autoscaling, runtime architectural reconfiguration, load balancing, performance isolation, energy proportionality, failure-aware recovery, and portfolio scheduling under cost, SLA, energy, and risk constraints (Iosup et al., 2016). A plausible implication is that SAS is not defined by any particular loss function, but by the use of an explicit objective coupled to a runtime model that converts local observations into scheduling actions.

4. Representative realizations across domains

The literature contains several recurring SAS patterns: online learning of execution places, portfolio or policy routing, model-based budget decomposition, federated local protection, and self-managing work partitioning.

System	Self-aware state or model	Scheduling action
Dynamic Asymmetry Scheduler (Chen et al., 2020)	Performance Trace Table over task type, core, and width	Choose execution place and resource width
Pronto (Grammenos et al., 2021)	Streaming PCA subspace and rejection signal from local telemetry	Accept or reject incoming jobs locally
SimAS (Mohammed et al., 2019)	LoopSim/SimGrid prediction over remaining loop iterations	Switch among DLS techniques at runtime
iChunk (Booth et al., 2020)	Per-thread completed iterations and variance proxy $\delta = \epsilon \mu$6	Adapt chunk size and interact with work stealing
ASA (Wang et al., 7 Nov 2025)	XGBoost-centered classifier plus time-weighted voting	Switch among expert Linux schedulers
DSSP (Sun et al., 2023)	Histogram-based unloaded subtask response-time distributions	Assign task/subtask budgets and queue by EDFQ
SageSched (Gan et al., 9 Mar 2026)	Output-length distribution and analytic hybrid service cost	Gittins-index-based request scheduling

These systems demonstrate that SAS need not be centralized. Pronto is explicitly federated and asynchronous: each node maintains its own model, executes local accept/reject decisions, and only optionally contributes a compressed subspace upward for a global view (Grammenos et al., 2021). DSSP is likewise distributed across independent sensing administrative domains, with each IAD converting incoming task budgets into exact subtask queuing deadlines while preserving local autonomy and privacy (Sun et al., 2023). By contrast, ASA is local to a machine but still layered: the workload recognizer is hardware-agnostic, while the mapping from scenario to scheduler is machine-specific (Wang et al., 7 Nov 2025).

These works also show that SAS does not require end-to-end deep learning. Dynamic asymmetry scheduling uses a small online table with weighted updates (Chen et al., 2020). DSSP relies on order statistics, queueing models, and histogram measurements (Sun et al., 2023). iChunk uses a simple throughput-based heuristic and work stealing (Booth et al., 2020). SimAS uses asynchronous simulation as a predictive controller (Mohammed et al., 2019). The literature therefore suggests two broad implementation families: analytic SAS, which derives decisions from explicit formulas and measured distributions, and learned SAS, which derives them from embeddings, classifiers, or policy optimization.

5. SAS for LLM systems and generative models

Recent LLM work has made SAS unusually explicit. SageSched presents itself as a concrete realization of self-aware scheduling for LLM inference: it explicitly models stochastic service demand, multi-resource cost, and the interaction between these and the scheduling objective TTLT (Gan et al., 9 Mar 2026). Its demand predictor is training-free and history-based: using prompt embeddings and cosine similarity, it forms an empirical output-length distribution from recent semantically similar prompts, with FAISS IndexFlat retrieval and a default similarity threshold $\delta = \epsilon \mu$7 (Gan et al., 9 Mar 2026). That distribution is pushed through the hybrid cost model $\delta = \epsilon \mu$8, and the resulting cost distribution is scheduled by a Gittins-index policy that can update as requests cross bucket boundaries during execution (Gan et al., 9 Mar 2026). Testbed experiments report an efficiency improvement of over 28.7% (Gan et al., 9 Mar 2026).

A distinct but related use of the term appears in diffusion LLMs. There, Self-Aware Scheduling is the learning of the unmasking schedule, or “order of thought,” for masked diffusion LLMs using the model’s own pathwise log-likelihood as a dense reward (Xu et al., 22 Jun 2026). The core reward is

$\delta = \epsilon \mu$9

and the self-aware loss upper-bounds the sequential decoding mismatch through a joint KL identity (Xu et al., 22 Jun 2026). Order selection is then cast as policy optimization with a frozen denoiser and Group Relative Policy Optimization. On Sudoku with a 1B masked diffusion model, SAS improves puzzle accuracy from 82.0% for the best heuristic schedule to 91.8%, and reaches 97.5% with second-stage fine-tuning along learned trajectories (Xu et al., 22 Jun 2026). On LLaDA-8B, SAS improves pass@1 on GSM8K from 64% to 76% and on MBPP from 39.5% to 41% (Xu et al., 22 Jun 2026).

This extension is conceptually important because it broadens scheduling from machine-resource allocation to inference-trajectory control. In SageSched, SAS schedules requests competing for GPU compute and memory (Gan et al., 9 Mar 2026). In diffusion LMs, SAS schedules the order in which tokens are revealed (Xu et al., 22 Jun 2026). The common element is still self-awareness: decisions are derived from the model’s own estimate of what is costly, informative, or likely to succeed.

6. Trade-offs, misconceptions, and future directions

A common misconception is that SAS names a single algorithm. The literature suggests the opposite. ASA explicitly rejects the “one-policy-fits-all” approach and instead routes workloads to a portfolio of expert schedulers (Wang et al., 7 Nov 2025). SimAS concludes that no single DLS technique can deliver the absolute best performance in all scenarios and therefore performs simulation-assisted algorithm selection at runtime (Mohammed et al., 2019). The adaptive loop scheduler iChunk likewise argues for self-managing chunk size because expert tuning is otherwise required and no static loop-scheduling method is uniformly best (Booth et al., 2020).

Another misconception is that self-awareness implies centralized control or heavy online learning. Pronto distributes intelligence to each node and uses federation only to build a global embedding when needed (Grammenos et al., 2021). DSSP derives exact local budgets from global SLOs without requiring a global real-time scheduler (Sun et al., 2023). Dynamic asymmetry scheduling learns with a lightweight trace table rather than a large model (Chen et al., 2020). These systems indicate that SAS can be distributed, local, and analytically grounded.

The major limitations recur across domains. Monitoring, model maintenance, and reconfiguration incur overhead; SAPA notes unanswered questions about convergence, stability, training overhead, and scalability of the distributed reconfiguration manager (Kinsy et al., 2018). Pronto assumes attractive scalability in the absence of communication latency and depends on empirical correlation between projection spikes and CPU Ready spikes (Grammenos et al., 2021). SimAS depends on accurate simulator calibration and is limited by non-preemptive chunk assignments and simulation overhead (Mohammed et al., 2019). DSSP assumes independence and relies on accurate unloaded response-time estimation (Sun et al., 2023). In SageSched, fairness is not explicitly optimized and the policy inherits SRPT/SJF-like trade-offs that favor short jobs (Gan et al., 9 Mar 2026). In diffusion SAS, the policy is trained under teacher forcing, so a train-test mismatch remains when free-running generation deviates from the teacher-forced state trajectory (Xu et al., 22 Jun 2026).

A further boundary appears in formal real-time analysis. Suspension-aware schedulability tests for EDF-like schedulers provide a unifying verification framework for EDF, FIFO, EQDF, SAEDF, and TFP under arbitrary-deadline self-suspending sporadic task systems (Günzel et al., 2021). Although this work is not framed as SAS, it supplies a formal feasibility layer that a self-aware runtime could use when adapting policy parameters or switching among EDF-like policies. This suggests a broader agenda in which SAS combines runtime introspection, predictive or analytic self-models, explicit objective functions, and formal safety envelopes.

The literature therefore points toward a stable core idea: a scheduler becomes self-aware when it uses knowledge of its own runtime behavior, workload structure, and goals to alter scheduling decisions online. Whether that knowledge is represented as unhappiness propagation (Nikseresht et al., 2010), a performance trace table (Chen et al., 2020), a telemetry subspace (Grammenos et al., 2021), a simulator (Mohammed et al., 2019), a scheduler portfolio and mapping table (Wang et al., 7 Nov 2025), a hybrid analytic service-cost distribution (Gan et al., 9 Mar 2026), or a pathwise likelihood over decoding orders (Xu et al., 22 Jun 2026), the defining move is the same: scheduling is no longer a fixed heuristic, but an adaptive inference problem grounded in the system’s own state.