Preemption Thresholds in Scheduling Systems

• Preemption thresholds are control rules that determine when a running activity may be interrupted, balancing trade-offs among schedulability, memory usage, latency, and fairness.
• They are applied in contexts such as real-time scheduling, AoI systems, dynamic DAG scheduling, and GPU serving, each with unique operational metrics and state-dependent conditions.
• Research demonstrates that optimal threshold settings can reduce memory usage and improve system performance by effectively managing preemption frequency and associated overhead.

Preemption thresholds are control rules that determine when a running activity may be interrupted, when interruption is forbidden, or how often interruption may occur. In the cited literature, the term spans several distinct constructions: task-local threshold priorities in fixed-priority real-time scheduling, state-dependent age thresholds in status update systems, window sizes that bound how much of a schedule may be reconsidered, and latency- or rate-bounding mechanisms for production inference services (Thilakasiri et al., 27 Aug 2025, Banerjee et al., 2024, Liu et al., 9 Apr 2026). Across these settings, thresholds are used to regulate trade-offs among schedulability, freshness, fairness, memory usage, latency, and preemption overhead.

1. Conceptual scope and principal forms

The literature does not use a single universal definition of a preemption threshold. Instead, it uses threshold variables to encode different kinds of admissibility conditions for interrupting work. In the 3-phase task model, a threshold is attached to a task and restricts which higher-priority tasks may preempt it. In Age of Information (AoI) systems, thresholds depend on state variables such as the age at the monitor, the age of the packet in service, or both. In dynamic graph scheduling, the threshold is a window size $K$ that determines which recent task graphs remain eligible for rescheduling. In GPU serving systems, thresholds appear as cooldown intervals, rate limits, or fixed swap penalties that constrain when preemption is worthwhile or permissible (Thilakasiri et al., 27 Aug 2025, Banerjee et al., 2024, Khodabandehlou et al., 3 Feb 2026, Yildiz et al., 19 May 2026, Liu et al., 9 Apr 2026).

Setting	Threshold variable	Operational meaning
3-phase real-time tasks	$\theta_i \geq P_i$	Only tasks with nominal priority greater than $\theta_i$ may preempt $\tau_i$
Status update systems	$v_{th,1}, v_{th,2}$, or $\Gamma^{(i)}$	Preemption depends on monitor age, packet age, or both
Dynamic DAG scheduling	$K$	Only the most recent $K$ task graphs are rescheduled
Production GPU colocation	$T_{\text{cool}}$, reclamation-rate targets	Bounds compute preemption rate and memory reclamation frequency
Web query preemption	fixed time quantum $q$	Query is suspended after a bounded execution slice
Priority polling	threshold $\theta_i \geq P_i$0	Server switches from $\theta_i \geq P_i$1 to $\theta_i \geq P_i$2 when $\theta_i \geq P_i$3 reaches $\theta_i \geq P_i$4

This diversity is substantive rather than terminological. Some thresholds are hard feasibility constraints, some are optimal stopping rules, and some are engineering knobs that upper-bound interference. A plausible implication is that “preemption threshold” is best understood as a class of control structures rather than a single scheduling primitive.

2. Threshold priorities and limited preemption in real-time task models

In the sporadic 3-phase task model, each task consists of a read phase $\theta_i \geq P_i$5, an execute phase $\theta_i \geq P_i$6, and a write phase $\theta_i \geq P_i$7. The $\theta_i \geq P_i$8- and $\theta_i \geq P_i$9-phases are non-preemptive, while the $\theta_i$0-phase is potentially preemptive. The model considered is the keep-in-core preemption model: if a task is preempted during its $\theta_i$1-phase, its local memory remains resident and the preempting task is stacked on top of it. This makes preemption a memory-management problem as well as a response-time problem (Thilakasiri et al., 27 Aug 2025).

Preemption thresholds, originally from Wang and Saksena, 1999, are used to limit which tasks may preempt others. Each task $\theta_i$2 is assigned a nominal priority $\theta_i$3 and a threshold $\theta_i$4. During execution, $\theta_i$5 can only be preempted by tasks with nominal priority greater than its threshold. The immediate significance is that unnecessary preemptions can be removed without moving to a fully non-preemptive regime. The paper develops a worst-case response time (WCRT) analysis and a worst-case memory requirement analysis for sporadic 3-phase tasks under partitioned fixed-priority scheduling with preemption thresholds. Tasks are grouped into categories A–F to characterize intra-core interference, intra-core blocking, and the effects of thresholds on schedulability and local memory demand (Thilakasiri et al., 27 Aug 2025).

The memory analysis is organized around the longest possible preemption chain of resident tasks. A task set is memory-feasible if, for every core and every task on that core, the sum of the memory requirements along the relevant preemption chain does not exceed the local memory size $\theta_i$6:

$\theta_i$7

This criterion makes explicit that thresholds control not only temporal interference but also stack-like scratch-pad occupancy (Thilakasiri et al., 27 Aug 2025).

The threshold assignment problem is addressed through an adaptation of the Maximal Preemption Threshold Assignment Algorithm (MPTAA) of Ghattas et al. 2007. With unique priorities, incrementing $\theta_i$8 affects at most one local higher-priority task, and when $\theta_i$9 is increased for $\tau_i$0, only the WCRT of a task $\tau_i$1 with $\tau_i$2 needs to be checked for continued schedulability. The evaluation reports that preemption thresholds can reduce memory usage by $\tau_i$3 compared to fully preemptive scheduling, while maintaining schedulability ratios $\tau_i$4 compared to non-preemptive scheduling. The same evaluation states that fully preemptive and threshold-limited scheduling achieve the same high schedulability, whereas non-preemptive execution suffers from blocking (Thilakasiri et al., 27 Aug 2025).

Taken together, these results qualify a common simplification in fixed-priority analysis: fully preemptive execution is not the unique route to high schedulability, and non-preemptive execution is not the unique route to low memory demand. Threshold priorities provide an intermediate regime in which both quantities are analyzed jointly.

3. Threshold policies for information freshness

A major body of work treats preemption thresholds as state-dependent policies for minimizing AoI or Peak Age of Information (PAoI). In a time-slotted status update system with an error-free preemptive queue, the problem is formulated as a Markov decision process with state $\tau_i$5, where $\tau_i$6 is the age at the monitor and $\tau_i$7 is the age of the packet in the server. The cost is $\tau_i$8. The optimal policy is stationary and, under certain conditions, has a threshold structure depending on monitor age and server-packet age. The same analysis shows that zero-wait sampling is always optimal, derives a sufficient condition for an always-preempt policy,

$\tau_i$9

and presents a necessary condition through the recursive sequence $v_{th,1}, v_{th,2}$0. It also introduces a double-threshold policy with two parameters $v_{th,1}, v_{th,2}$1 and $v_{th,1}, v_{th,2}$2, expressed as

$v_{th,1}, v_{th,2}$3

For geometric service times, the sufficient condition holds and always-preempt is optimal; for general service-time distributions, the double-threshold structure is shown to be optimal under some assumptions on the queue statistic (Banerjee et al., 2024).

A related MEC formulation studies PAoI when packets must first be computed at an edge server. Two server models are considered: computing preemption, in which a newly arrived packet replaces the packet in computation, and non-preemption, in which the new packet waits in the queue. The main structural result is that a fixed threshold policy is optimal in the non-preemptive system for arbitrary transmission-time and computation-time distributions, while in the preemptive system a transmission-aware threshold policy is optimal when the computing time is exponentially distributed. The preemptive threshold has the form $v_{th,1}, v_{th,2}$4, so the waiting rule depends on the observed transmission time $v_{th,1}, v_{th,2}$5. The numerical results further show that preemptive systems are not always superior to non-preemptive systems, and that as the ratio of the mean transmission time to the mean computation time increases, the optimal threshold increases in preemptive systems but decreases in non-preemptive systems (Zhu et al., 2024).

These papers establish two recurring points. First, threshold optimality is highly distribution-dependent: memoryless or geometric settings favor aggressive preemption more often than general distributions do. Second, the relevant state variable is not always job progress in the conventional sense; it may instead be the joint age state of the system and the in-service packet.

4. Multi-threshold and probabilistic policies in AoI systems

The threshold literature in AoI has also moved beyond single scalar cutoffs. For a bufferless discrete-time system with random update arrivals, multi-threshold preemption policies are parameterized by a vector of thresholds $v_{th,1}, v_{th,2}$6 with $v_{th,1}, v_{th,2}$7 and $v_{th,1}, v_{th,2}$8. Preemption decisions depend jointly on the current AoI $v_{th,1}, v_{th,2}$9, the current Age of Packet $\Gamma^{(i)}$0, and a set of preemption probabilities $\Gamma^{(i)}$1 associated with the active AoI segment. The paper develops an Absorbing Markov Chain framework for exact time-average AoI evaluation, proves that if arbitrary thresholds are allowed then the optimal policy is deterministic, and shows that if $\Gamma^{(i)}$2 and the service-time hazard rate is decreasing, then always preempting is optimal. The same work compares probabilistic preemption, packet-age-based preemption, and packet-and-system-age preemption, and reports that multi-threshold packet-and-system-age policies significantly outperform both traditional probabilistic preemption policies and single-threshold policies (Liyanaarachchi et al., 15 May 2026).

A further generalization appears in multi-sensor correlated systems, where each sensor $\Gamma^{(i)}$3 has a source-specific preemption probability $\Gamma^{(i)}$4 and updates can contain information about multiple processes according to a correlation matrix $\Gamma^{(i)}$5. The resulting AoI optimization problem becomes a sum of linear ratios, which is NP-hard in general, but the paper derives a branch-and-bound procedure with an iteration bound that is linear in the number of processes and logarithmic in the reciprocal of the target error. Its central structural conclusion is that the diversity of processes within a sensor’s packets, as captured by the correlation matrix, plays a more significant role in preemption priority than the number of updates. In this setting, optimal “thresholds” are not merely temporal; they are encoded in process-aware preemption probabilities (Erbayat et al., 11 Feb 2025).

These results suggest that single-threshold heuristics are often too coarse once arrivals are random, service times are non-memoryless, or updates have heterogeneous informational content. The optimal preemption frontier can depend simultaneously on AoI, packet age, and source informativeness.

5. Bounded-preemption thresholds in modern computing systems

In large-scale LLM serving, preemption thresholds are shaped by hardware and model-state movement rather than by classical queueing ages. In a multi-model setting with partial CPU–GPU offloading, preemption is defined as pausing a running inference job, transferring its KV cache from GPU to CPU, unloading its model from GPU memory, running another job and model, and later restoring the original model and job state. The empirical finding is that model state reload dominates the total preemption cost, accounting for over $\Gamma^{(i)}$6–$\Gamma^{(i)}$7 of the total overhead, while KV cache migration contributes less than $\Gamma^{(i)}$8 even for contexts up to 5,000 tokens. Overhead is nearly constant regardless of when preemption occurs, because model reload is the fixed bottleneck. For a 7,000-token inference job, the worst-case full unload/reload overhead is reported as only $\Gamma^{(i)}$9–$K$0 of baseline latency, and the paper concludes that the optimal preemption threshold does not depend on how far an inference job has progressed. Instead, schedulers can treat preemption cost as a fixed penalty per $K$1 pair and use preemption selectively for high-priority admission or VRAM pressure (Yildiz et al., 19 May 2026).

Production GPU colocation systems treat thresholds as bounds on both latency and rate. Valve jointly bounds preemption latency and preemption rate by combining channel-controlled compute isolation, page-fault-free memory reclamation, and dynamic memory reservation. It provides sub-millisecond compute preemption at most once per online request and rate-limited sub-layer memory reclamation. The cooldown interval is set as

$K$2

where $K$3 is the maximum observed gap between decode iterations; this is used to avoid repeated wakeups of offline work between iterations and to ensure at most one preemption over the lifetime of an online request. Deployed on 8,054 GPUs in production, Valve improves cluster utilization by $K$4, translating to a 2,170 GPU save, while incurring less than $K$5 TTFT increase and less than $K$6 TPOT increase across workloads (Liu et al., 9 Apr 2026).

Dynamic task-graph scheduling introduces a different threshold construction: Last-$K$7 Preemption. When a new DAG arrives, only the most recent $K$8 graphs remain eligible for rescheduling, while older allocations are locked. The paper compares preemptive, non-preemptive, and partial-preemptive strategies on synthetic, RIoTBench, WFCommons, and adversarial workloads, and reports that moderate $K$9 values such as $K$0, $K$1, and $K$2 achieve most of the makespan and utilization gains of full preemption while preserving fairness and low runtime overhead. Once a graph ages out of the Last-$K$3 window, it is never rescheduled again, so $K$4 acts as an explicit trade-off knob between adaptability and stability (Khodabandehlou et al., 3 Feb 2026).

Learning-augmented online scheduling formalizes a preemption threshold as a preemption budget. The benchmark

$K$5

is defined as the minimal information-theoretic benchmark for the number of preemptions. An algorithm has a bounded-preemption guarantee if the number of preemptions per job is within $K$6 times this benchmark. The paper gives $K$7-competitive algorithms for single, unrelated, and malleable machine settings that use only $K$8 preemptions per job under accurate predictions and $K$9 preemptions per job under noisy predictions, with the unrelated-machine SNAP algorithm achieving a competitive ratio of $T_{\text{cool}}$0 and a logarithmic preemption bound in the prediction error (Blue et al., 22 May 2026).

Web systems expose yet another threshold form: the fixed time quantum. SaGe suspends SPARQL query execution after a fixed time quantum, serializes the plan state, and allows later resumption by the client. The model is tractable only if suspend/resume overhead is negligible relative to the quantum. The reported suspend overhead is approximately $T_{\text{cool}}$1 ms, the resume overhead approximately $T_{\text{cool}}$2 ms, and with a $T_{\text{cool}}$3 ms quantum the overhead is approximately $T_{\text{cool}}$4. The system reports improvements by several orders of magnitude in average total query execution time and time for first results compared with existing approaches (Minier et al., 2019).

A common implication across these systems is that the useful threshold variable is often not “when should I interrupt?” in isolation, but “how much interruption can the system absorb?”—measured as swap latency, preemption count, reclamation frequency, or quantum-relative overhead.

6. Queueing thresholds and heavy-traffic interpretations

Threshold service policies also appear in classical queueing models. In a three-queue $T_{\text{cool}}$5 priority polling system, $T_{\text{cool}}$6 is served exhaustively, $T_{\text{cool}}$7 is served when $T_{\text{cool}}$8 is empty and is immediately preempted if a $T_{\text{cool}}$9 customer arrives, and $q$0 is served only when both $q$1 and $q$2 are empty. The threshold parameter $q$3 enters through the rule that if $q$4 reaches the preset threshold $q$5 while $q$6 is empty, the server preemptively switches from $q$7 to $q$8, with service resuming from scratch for preempted customers. Under heavy traffic, where $q$9 becomes critically loaded, the scaled queue length of $\theta_i \geq P_i$00 is exponentially distributed and independent of the stable queues, and the joint queue-length distribution of $\theta_i \geq P_i$01 and $\theta_i \geq P_i$02 matches that of a corresponding $\theta_i \geq P_i$03-policy vacation system. The tail asymptotics of the stable queues have the same prefactors and decay rates as classical $\theta_i \geq P_i$04 preemptive priority queues (Liu et al., 2014).

This queueing result is notable because the threshold does not merely trigger an isolated interruption event. It changes the asymptotic decomposition of the system into a critically loaded component and a stable component that behaves like a vacation model. The paper also states that higher $\theta_i \geq P_i$05 keeps the server at $\theta_i \geq P_i$06 longer before switching back, which may increase delays for $\theta_i \geq P_i$07 while reducing preemption frequency (Liu et al., 2014).

A broader reading of the threshold literature is therefore that preemption thresholds are mechanisms for shaping system structure, not just for deciding individual interrupt events. In real-time systems they shape interference sets and memory-feasible preemption chains; in AoI systems they shape the geometry of the no-preempt and preempt regions; in production serving they shape latency and rate guarantees; and in queueing systems they shape heavy-traffic asymptotics and class protection.