Revisiting Real-Time Interval and Throughput Maximization

Abstract: Job throughput maximization is the central maximization problem in scheduling. Interval scheduling is the special case of throughput maximization when jobs are intervals and therefore there is no slack available in which to schedule a job. It is interesting to know to what extent results for interval scheduling can be extended to the more general throughput problem in the real-time model. For the unweighted and proportionally weighted throughput problem (where the weight or value $w_i$ of a job $J_i$ is its processing time $p_i$), there are constant competitive real-time scheduling algorithms using preemption with restarting. More generally, the result for proportionally weighted interval scheduling can be extended to C-Benevolent weight functions. We also introduce a new real-time model in which jobs are announced before the actual release time of a job. We show that with sufficient advance notice, we can obtain a constant competitive ratio for proportionally weighted throughput {\it without any preemption}. However, this advance notice result does not extend to arbitrary C-Benevolent and D-Benevolent weight functions. Finally, we show that unlike interval scheduling, unweighted throughput using preemption with revoking admits no constant competitive ratio when the number of distinct processing times is unrestricted. More precisely, for instances with at most $k$ distinct processing times, we give a lower bound of $1/(k+1)$ and a deterministic $1/(2k)$-competitive algorithm.

• The paper extends the τ-Persist framework to C-Benevolent and D-Benevolent throughput scheduling with restarting, achieving a deterministic 1/5-competitive ratio.
• Advance notice can replace preemption for proportional weights, yielding a ratio of (t−t²)/(1+t−t²) for t≤1/2 and 1/5 for larger t, but arbitrary benevolent weights admit no constant ratio.
• For unweighted throughput with revoking and at most k processing times, the paper gives a 1/(2k)-competitive algorithm and a 1/(k+1) lower bound, showing performance vanishes as k grows.

Overview and motivation

Weighted Throughput Maximization is a foundational problem in scheduling: jobs arrive with release times $r_i$, processing times $p_i$, deadlines $d_i$, and weights $w_i$, and an algorithm must select and schedule a subset of jobs on one machine so as to maximize total weight of jobs completed by their deadlines. Interval selection is the special case in which every job has zero slack ($r_i + p_i = d_i$), so scheduling decisions reduce to selection decisions. The paper by Borodin, He, and Mottu (2607.16163) asks to what extent the known results for interval selection in the real-time model — where a job becomes known at its release time — extend to the more general throughput setting, and under which forms of preemption.

The paper studies deterministic algorithms and distinguishes three preemption regimes: preemption with resumption (interrupted work is retained), preemption with restarting (interrupted work is lost and the job must be redone from scratch), and preemption with revoking (an aborted job is permanently lost). All competitive ratios are stated as fractions at most one, and positive results are strict; negative results can be made asymptotic via disjoint copies of the adversarial constructions.

Three main contributions

The paper's results can be summarized as follows.

Setting	Weight structure	Preemption model	Result
Real-time throughput	C-Benevolent and D-Benevolent	Restarting	$\frac{1}{5}$-competitive algorithm (vs. $\frac{1}{4}$ optimal for intervals)
Real-time throughput with advance notice	Proportional weights ($w_i = p_i$)	None	$\frac{t-t^2}{1+t-t^2}$-competitive for $t \le \frac{1}{2}$; $p_i$0 for $p_i$1
Advance notice, arbitrary weights	C- or D-Benevolent	None	No constant competitive ratio for any $p_i$2
Real-time throughput, $p_i$3 processing times	Unweighted	Revoking	Lower bound $p_i$4, matching upper bound $p_i$5

C-Benevolent and D-Benevolent throughput with restarting

The central positive result extends Woeginger's $p_i$6-competitive algorithm for interval selection [Woeginger94] to throughput instances with positive slack. The algorithm, called $p_i$7-Persist, always runs the highest-weight available job, interrupting the current job only when the new job has more than $p_i$8 times its weight, or when the new job completes earlier with at least as much weight (the latter case being relevant only for D-Benevolent instances). Interrupted jobs return to the pending set rather than being lost, which distinguishes restarting from revoking and is precisely what makes the extension to positive slack possible.

The analysis adapts Woeginger's charging argument. Each completed job $p_i$9 is assigned a range: the interval spanning the start of the earliest job in its predecessor chain (the sequence of jobs interrupted to schedule $d_i$0) through the end of its successor (the largest job that could intersect $d_i$1 on the right). An observation establishes that every job not completed by the algorithm must be schedulable within the range of some completed job. The key lemma then shows, via Karamata's inequality for C-Benevolent functions, that any optimal schedule confined to the range of a completed job $d_i$2 has total weight at most $d_i$3. Summing the lost weight against the algorithm's gain yields a competitive ratio of

$d_i$4

maximized at $d_i$5, giving a $d_i$6-competitive deterministic algorithm. A D-Benevolent analogue is proved with a point-covering argument instead of Karamata's inequality, and the same ratio holds for equal-length instances with arbitrary weights. Notably, when slack is zero the analysis recovers the $d_i$7 ratio, matching Woeginger's $d_i$8 for $d_i$9; the charging lemma thus constitutes an alternative proof of his result. The gap between $w_i$0 and the $w_i$1 upper bound inherited from interval selection — the optimal ratio for C-Benevolent throughput — is left open.

Advance notice: eliminating preemption

The paper introduces a real-time variant in which each job is a 5-tuple $w_i$2, where the algorithm learns of the job at announcement time $w_i$3, though the job still cannot execute before $w_i$4. An instance has $w_i$5-advance-notice if $w_i$6 for all jobs.

The augmented algorithm $w_i$7-Persist$w_i$8 simulates $w_i$9-Persist into the future on all announced jobs; when the simulation reveals that a would-be scheduled job would be preempted by a not-yet-released job, the algorithm declines to start it. A structural theorem shows that under $r_i + p_i = d_i$0-advance-notice, the algorithm's first-level interruptions never actually occur, so no preemption is needed. Consequently, for proportional weights and $r_i + p_i = d_i$1, the algorithm achieves $r_i + p_i = d_i$2-competitiveness without any preemption, improving to $r_i + p_i = d_i$3 for $r_i + p_i = d_i$4 (and to $r_i + p_i = d_i$5 on zero-slack instances).

This positive result is sharply bounded from above. An adversarial construction in which the algorithm commits to a long job $r_i + p_i = d_i$6 and the adversary then fills its execution window with a chain of non-preemptible short jobs shows that no non-preemptive algorithm can be better than $r_i + p_i = d_i$7-competitive, for any amount of advance notice $r_i + p_i = d_i$8. As $r_i + p_i = d_i$9, this bound approaches $\frac{1}{5}$0, so advance notice alone can never yield a $\frac{1}{5}$1-competitive non-preemptive algorithm even for proportional weights.

Moreover, the benefit of advance notice does not extend beyond proportional weights. For C-Benevolent functions, an adversary chooses $\frac{1}{5}$2, forcing any non-preemptive algorithm to take a weight-$\frac{1}{5}$3 job while the optimum takes a single job of weight $\frac{1}{5}$4, for arbitrary $\frac{1}{5}$5. For D-Benevolent (in particular, unweighted) instances, the adversary packs $\frac{1}{5}$6 disjoint short jobs strictly inside the window of the first job. In both cases the competitive ratio is unbounded, regardless of $\frac{1}{5}$7.

Unweighted throughput with revoking

The third contribution is a separation between interval selection and throughput under revoking. In interval selection, the Faigle–Nawijn greedy algorithm is optimal in the real-time model with revoking; the paper shows this does not carry over to throughput.

Upper bound. For instances with at most $\frac{1}{5}$8 distinct processing times, a $\frac{1}{5}$9-length EDF algorithm — always preferring shorter jobs, breaking ties by earliest deadline — is shown to be $\frac{1}{4}$0-competitive. The proof extends the indirect charging technique of Borodin and Karavasilis [BorodinK23]: each optimal job is charged to a completed "descendant" of the job running at its optimal start time, and a counting argument over revocation chains shows each completed job receives at most $\frac{1}{4}$1 charges.

Lower bound. A recursive adversarial gadget shows that for every $\frac{1}{4}$2, there is an instance with at most $\frac{1}{4}$3 distinct processing times on which any deterministic algorithm completes at most one job while the optimum completes $\frac{1}{4}$4, yielding an upper bound of $\frac{1}{4}$5 on any algorithm's competitive ratio. The base case ($\frac{1}{4}$6) is a simple bait-and-urgent-job construction forcing a choice between two incompletable alternatives; the inductive step nests a $\frac{1}{4}$7-level gadget inside the execution window of a larger "bait" job, so that whichever way the algorithm responds — keep the bait, revoke it, or defer it — it loses all but one job. Since $\frac{1}{4}$8, no deterministic algorithm achieves a constant competitive ratio for unweighted throughput with revoking when the number of distinct processing times is unrestricted. This contrasts with the restarting model, where Hoogeveen, Potts, and Woeginger's $\frac{1}{4}$9-competitive algorithm is optimal.

Limitations and open questions

Several gaps remain. For C-Benevolent and D-Benevolent throughput with restarting, the $w_i = p_i$0 upper bound is not known to be tight; only the inherited $w_i = p_i$1 lower bound applies. For bounded-processing-time revoking instances, the gap between $w_i = p_i$2 and $w_i = p_i$3 is open. The advance-notice model is analyzed only for proportional weights in the positive direction, and the paper does not address whether a cost for insufficient advance notice changes the landscape. All results are deterministic; the authors ask explicitly which bounds can be improved by randomization, noting the existing barely random $w_i = p_i$4 and $w_i = p_i$5 results for single-processing-time weighted and unweighted instances as evidence that 1-bit randomness may help more broadly. Finally, the observation that a competitive ratio $w_i = p_i$6 for interval selection maps to $w_i = p_i$7 for the analogous throughput problem is presented as a technique whose applicability to other real-time problems is unexplored.

Conclusion

The paper demonstrates that several structural results for real-time interval selection extend to throughput maximization with positive slack, provided restarting replaces revoking: the $w_i = p_i$8-Persist framework yields a $w_i = p_i$9-competitive deterministic algorithm for all C-Benevolent and D-Benevolent weight classes. It also shows that advance notice is a substitute for preemption only for proportional weights, with matching impossibility results showing the technique fails for general benevolent weight functions and that no non-preemptive algorithm can beat $\frac{t-t^2}{1+t-t^2}$0 regardless of notice. Finally, it establishes a qualitative separation between interval selection and throughput under revoking, ruling out constant competitive ratios in the unweighted case while providing a $\frac{t-t^2}{1+t-t^2}$1-competitive algorithm for bounded processing times. The work clarifies precisely which preemption and information assumptions are necessary for competitiveness in real-time throughput scheduling, and leaves the tightness of several of its bounds as concrete open problems.