Past-Future Scheduler: Cross-Domain Insights

• Past-Future Scheduler is a design pattern that uses historical data to guide current decisions by explicitly modeling future outcomes.
• It underpins diverse applications such as sequential recommendation, LLM workflow scheduling, quantum resource management, and kernel-level predictive control.
• The mechanism integrates past observations and future predictions through adaptive scheduling, dynamic weight strategies, and predictive controllers to balance performance and resource constraints.

Past-Future Scheduler denotes a family of mechanisms that use past observations, past state, or past tasks to guide present decisions while explicitly estimating future consequences. In the literature, the designation spans sequential recommendation, heterogeneous LLM workflow serving, temporally correlated task selection in sequence learning, quantum resource scheduling, kernel scheduling, and continuous batching for LLM inference. In several cases the phrase is an expository framing rather than the original method name, but the recurring structure is the same: the scheduler or training controller preserves information derived from the past and optimizes current action using a model of future utility, future memory demand, or future supervision (Zhang et al., 2022, Huang et al., 8 May 2026, Gong et al., 14 Jul 2025).

1. Conceptual scope and recurrent structure

Across the cited works, the “past” component is not uniform. In sequential recommendation it is the historical interaction segment; in LLM workflow DAG scheduling it is the execution state inherited from earlier stages, including model residency, parent-output locality, prefix reuse, and device availability; in Active Volume scheduling it is stale-state storage; and in LLM serving it is the historical distribution of output lengths. The “future” component is equally heterogeneous: future segments in recommendation, downstream execution state in workflow serving, bridge qubits in logical-cycle scheduling, or projected KV-cache occupancy in continuous batching (Zhang et al., 2022, Huang et al., 8 May 2026, Heavey et al., 6 Mar 2026, Gong et al., 14 Jul 2025).

Domain	Past signal	Future signal
Sequential recommendation	Historical segment $s_{\text{past}}(t)$	Future segment $s_{\text{future}}(t)$
Heterogeneous LLM workflows	$s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$	Downstream state within horizon $H$
LLM serving	Historical output lengths $L_h$	Future required memory $\mathbf{M}^*$
Active Volume architecture	Stale-state storage qubits	Bridge qubits

The optimization objectives also differ. DualRec minimizes a weighted combination of past loss, future loss, and regularization. The learnable scheduler for temporally correlated tasks maximizes main-task validation performance through bi-level optimization. FATE optimizes normalized makespan and normalized P95 latency through horizon-aware frontier planning. LightLLM maximizes goodput under TTFT and MTPOT constraints. The Active Volume scheduler minimizes logical cycles while accounting for bridge and stale-state overheads. This suggests that “Past-Future Scheduler” functions as a cross-domain design pattern rather than a single standardized algorithm (Wu et al., 2020, Huang et al., 8 May 2026, Gong et al., 14 Jul 2025, Heavey et al., 6 Mar 2026).

2. DualRec and the sequential recommendation formulation

In sequential recommendation, the central problem is the training–inference gap created when future context is available during training but unavailable at inference. Standard autoregressive SR optimizes next-item prediction from past-only context, whereas masked or bidirectional methods optimize $p(i_t \mid x_{\text{past}}, x_{\text{future}})$ during training and then collapse to $p(i_t \mid x_{\text{past}}, \text{NULL})$ at inference. DualRec addresses this discrepancy by separating past and future modeling into two encoders with different parameters but a shared item embedding layer $E^I \in \mathbb{R}^{|I| \times d}$: a past encoder $E_p$ for $s_{\text{future}}(t)$0 and a future encoder $s_{\text{future}}(t)$1 for $s_{\text{future}}(t)$2. The past encoder uses a left-to-right causal mask, whereas the future encoder uses a right-to-left causal mask. For Transformer instantiations, relative positional embeddings are defined by $s_{\text{future}}(t)$3, with $s_{\text{future}}(t)$4, and multi-scale masking is implemented through head-specific windows $s_{\text{future}}(t)$5 (Zhang et al., 2022).

DualRec couples disentanglement with bi-directional knowledge transfer. The regularizer is a symmetric KL term across attention heads,

$s_{\text{future}}(t)$6

and the total objective is

$s_{\text{future}}(t)$7

Here $s_{\text{future}}(t)$8 and $s_{\text{future}}(t)$9 are next-item cross-entropy losses from the two encoders, while $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$0 and $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$1 reuse the shared embedding layer as output embedding. Inference discards $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$2 and uses only $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$3, thereby removing the training–inference gap for the deployed model.

The implementation-oriented “Past-Future Scheduler” built on DualRec turns the fixed weights $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$4 and $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$5 into schedules. Recommended policies include past-emphasis warm-up,

$s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$6

regularization warm-up,

$s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$7

and directional KL weighting with $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$8 early in training to favor future-to-past transfer. A two-phase or three-phase curriculum is also described: past-only pretraining, joint training with $s_t=(\rho_t,\kappa_t,\ell_t,\tau_t)$9 and moderate $H$0, and optional past-only finetuning. The reported empirical guidance is that $H$1 around $H$2 is best, extreme $H$3 undertrains one encoder, and $H$4 must be moderate because too high a value causes performance drops.

The empirical setting uses Amazon Beauty, Sports and Outdoors, Toys and Games, and Yelp; all data are filtered for users and items with at least $H$5 interactions, with maximum sequence length $H$6. Baselines include GRU4Rec, Caser, HGN, RepeatNet, SASRec, S3-Rec, BERT4Rec, SRGNN, GCSAN, FMLP-Rec, and CLEA. Evaluation uses HR@1, HR@5, HR@10, NDCG@5, NDCG@10, and MRR with $H$7 negative samples per ground-truth item. DualRec achieves the best performance across all four datasets and metrics, with average gains versus the strongest baselines of roughly $H$8 HR@1, $H$9 HR@10, $L_h$0 NDCG@10, and $L_h$1 MRR. Compatibility experiments report consistent improvements when “Dual+BIT” is applied to SASRec, GRU4Rec, and FMLP-Rec. Training cost is approximately $L_h$2 the backbone cost, whereas inference cost is the same as a single backbone because only $L_h$3 is used.

3. Learnable task scheduling and dual past–future supervision in sequence learning

A second major lineage treats Past-Future scheduling as adaptive selection among temporally correlated tasks. In simultaneous machine translation, tasks differ by how much future input is available through a wait-$L_h$4 latency constraint; in forecasting, tasks differ by how far into the future the model predicts. The scheduler introduced for temporally correlated task scheduling defines a policy $L_h$5 over auxiliary tasks, conditioned on the current mini-batch and model status, and optimizes it jointly with the main model through bi-level optimization:

$L_h$6

$L_h$7

The practical optimizer alternates inner updates of $L_h$8 with outer REINFORCE updates of $L_h$9 using differential reward $\mathbf{M}^*$0 (Wu et al., 2020).

In simultaneous MT, the task family is $\mathbf{M}^*$1 and evaluation uses BLEU together with Average Proportion and Average Lagging. The scheduler architecture is an MLP with one hidden layer of size $\mathbf{M}^*$2 and tanh activation, using a $\mathbf{M}^*$3-dimensional feature vector that includes source and target length ratios, current and historical training losses, previous validation loss, historical validation losses, and relative training progress. On IWSLT En→Vi, for main tasks $\mathbf{M}^*$4, the scheduler consistently achieves the highest BLEU; for wait-3, the reported figure is $\mathbf{M}^*$5 versus MTL $\mathbf{M}^*$6, CL $\mathbf{M}^*$7, and best-single $\mathbf{M}^*$8. On WMT’15 En→De, the scheduler improves BLEU across latencies, with wait-7 reported at $\mathbf{M}^*$9 versus baseline $p(i_t \mid x_{\text{past}}, x_{\text{future}})$0. Strategy analysis shows nearly uniform sampling in early episodes and later concentration on subsets of tasks. Training slows by approximately $p(i_t \mid x_{\text{past}}, x_{\text{future}})$1–$p(i_t \mid x_{\text{past}}, x_{\text{future}})$2 versus vanilla wait-$p(i_t \mid x_{\text{past}}, x_{\text{future}})$3 because scheduler features require computing main-task losses.

A different interpretation appears in “Dual Past and Future for Neural Machine Translation,” where the scheduler is implicit rather than explicit. Past denotes source-side content already translated by the decoder, and Future denotes source-side content remaining to be translated. Both are modeled as groups of high-level capsules produced by a Guided Capsule Network applied to encoder outputs and the current decoder state. Dual supervision is provided by source-to-target and target-to-source NMT models: partial sub-sequences $p(i_t \mid x_{\text{past}}, x_{\text{future}})$4 and $p(i_t \mid x_{\text{past}}, x_{\text{future}})$5 supervise Past, while $p(i_t \mid x_{\text{past}}, x_{\text{future}})$6 and $p(i_t \mid x_{\text{past}}, x_{\text{future}})$7 supervise Future. The capsule-level losses are

$p(i_t \mid x_{\text{past}}, x_{\text{future}})$8

$p(i_t \mid x_{\text{past}}, x_{\text{future}})$9

with joint objective

$p(i_t \mid x_{\text{past}}, \text{NULL})$0

Training is synchronous and joint; there is no reported alternation schedule or annealing, and only one direction is used at test time (Yan et al., 2020).

The reported NMT gains are adequacy-oriented. On NIST ZH→EN, Transformer baseline is $p(i_t \mid x_{\text{past}}, \text{NULL})$1 average BLEU, Zheng et al. (2019) is $p(i_t \mid x_{\text{past}}, \text{NULL})$2, “Ours” is $p(i_t \mid x_{\text{past}}, \text{NULL})$3, and “Ours + Inde.Train.” is $p(i_t \mid x_{\text{past}}, \text{NULL})$4. On WMT14 EN→DE, the authors report $p(i_t \mid x_{\text{past}}, \text{NULL})$5 BLEU for their Transformer implementation and $p(i_t \mid x_{\text{past}}, \text{NULL})$6 for the proposed method. Human evaluation on ZH→EN reports under-translation at $p(i_t \mid x_{\text{past}}, \text{NULL})$7 versus $p(i_t \mid x_{\text{past}}, \text{NULL})$8 and over-translation at $p(i_t \mid x_{\text{past}}, \text{NULL})$9 versus $E^I \in \mathbb{R}^{|I| \times d}$0 compared with GDR. Decoding speed is $E^I \in \mathbb{R}^{|I| \times d}$1 the baseline Transformer. In both the explicit scheduler of temporally correlated tasks and the implicit scheduler of dual NMT supervision, present learning is organized by a controlled relation between already observed context and future-oriented auxiliary signal.

4. Workflow DAG scheduling and SLA-aware LLM serving

In heterogeneous LLM workflows, FATE treats the scheduler as a repeated frontier planner over a workflow DAG $E^I \in \mathbb{R}^{|I| \times d}$2 with execution state $E^I \in \mathbb{R}^{|I| \times d}$3. Here $E^I \in \mathbb{R}^{|I| \times d}$4 encodes model residency, $E^I \in \mathbb{R}^{|I| \times d}$5 encodes reusable prefix or cache metadata, $E^I \in \mathbb{R}^{|I| \times d}$6 records parent-output locations, and $E^I \in \mathbb{R}^{|I| \times d}$7 captures device next-available times. FATE does not solve a monolithic full-DAG problem. Instead, at each planning wave it constructs a ready frontier $E^I \in \mathbb{R}^{|I| \times d}$8, introduces binary variables $E^I \in \mathbb{R}^{|I| \times d}$9 for shard slot $E_p$0 of stage $E_p$1 on device $E_p$2, and maximizes a horizon-aware score

$E_p$3

The candidate score separates immediate and future terms,

$E_p$4

where $E_p$5 includes queueing, model loading, transfer, execution, and prefix reuse, and $E_p$6 values model residency continuity, parent-output locality, prefix reuse alignment, and device reachability within a finite horizon $E_p$7 (Huang et al., 8 May 2026).

On the real-DAG benchmark derived from WfCommons and executed on eight RTX 4090 GPUs, FATE achieves normalized makespan $E_p$8 and normalized P95 latency $E_p$9, reducing them by $s_{\text{future}}(t)$00 and $s_{\text{future}}(t)$01 over RoundRobin and by $s_{\text{future}}(t)$02 and $s_{\text{future}}(t)$03 over the strongest non-FATE baseline. In the controlled prefix-reuse suite, it remains strongest, with normalized makespan $s_{\text{future}}(t)$04 at repeat ratio $s_{\text{future}}(t)$05 and $s_{\text{future}}(t)$06 at repeat ratio $s_{\text{future}}(t)$07. Ablations show that removing future planning degrades normalized makespan from $s_{\text{future}}(t)$08 to $s_{\text{future}}(t)$09 $s_{\text{future}}(t)$10, the largest single drop; removing locality terms yields $s_{\text{future}}(t)$11 $s_{\text{future}}(t)$12, removing same-model bonus $s_{\text{future}}(t)$13 $s_{\text{future}}(t)$14, removing prefix terms $s_{\text{future}}(t)$15 $s_{\text{future}}(t)$16, and removing shard parallelism $s_{\text{future}}(t)$17 $s_{\text{future}}(t)$18. Frontier solves are reported as OPTIMAL, with mean $s_{\text{future}}(t)$19 ms, median $s_{\text{future}}(t)$20 ms, p95 $s_{\text{future}}(t)$21 ms, and max $s_{\text{future}}(t)$22 ms; elsewhere the paper states that every CP-SAT solve finishes within $s_{\text{future}}(t)$23 s under workloads.

A distinct but related scheduler appears in LLM serving under SLA guarantees. Here the core issue is continuous batching under uncertain output lengths, where conservative schedulers reserve memory up to max_new_tokens and aggressive schedulers overcommit based only on current occupancy. The Past-Future scheduler in LightLLM estimates the output-length distribution from a sliding window of completed requests,

$s_{\text{future}}(t)$24

samples predicted final lengths $s_{\text{future}}(t)$25 for both running and queued requests, and computes future memory at completion boundaries by sorting requests in descending order of predicted remaining length and evaluating

$s_{\text{future}}(t)$26

Admission is allowed only if the predicted future peak stays within capacity, optionally with reserved headroom $s_{\text{future}}(t)$27 (Gong et al., 14 Jul 2025).

The serving objective is goodput under SLA guarantees. The reported SLAs are TTFT $s_{\text{future}}(t)$28 s and MTPOT $s_{\text{future}}(t)$29 s for $s_{\text{future}}(t)$30B/$s_{\text{future}}(t)$31B models, and TTFT $s_{\text{future}}(t)$32 s and MTPOT $s_{\text{future}}(t)$33 s for the $s_{\text{future}}(t)$34B model. LightLLM evaluates window size and settles on $s_{\text{future}}(t)$35 as a robust default; scheduler overhead is reported as less than $s_{\text{future}}(t)$36 of LLM inference time. The abstract reports up to $s_{\text{future}}(t)$37–$s_{\text{future}}(t)$38 higher goodput than other schedulers under heavy loads. Detailed ablations on LLaMA-2 7B on A100-80G show, for Distribution-1, aggressive scheduling at watermark $s_{\text{future}}(t)$39 with current memory $s_{\text{future}}(t)$40, future required memory $s_{\text{future}}(t)$41, and eviction rate $s_{\text{future}}(t)$42, whereas Past-Future with reserved headroom $s_{\text{future}}(t)$43 yields current memory $s_{\text{future}}(t)$44, future required memory $s_{\text{future}}(t)$45, and eviction rate $s_{\text{future}}(t)$46. Similar patterns appear on Distribution-2 and Distribution-3. The method is explicitly justified as a balance between request queuing and harmful evictions.

5. Physical-resource scheduling and kernel-level predictive control

The Active Volume scheduler makes the past–future distinction literal at the level of logical qubits. A workspace qubit executes one Active Volume block in one logical cycle; a stale state is any qubit that sits idly while a decoder determines the basis for a reactive measurement; and a bridge qubit is the qubit from a Bell state that idles during a logical cycle while its sister qubit is used as the input for an AV block. The scheduler assigns each logical qubit a role in each logical cycle—workspace, stale-state storage, bridge qubit, memory data, or unused—and uses a greedy strategy to minimize logical cycles while respecting precedence, memory, workspace, and reaction-layer constraints. Runtime is then estimated by

$s_{\text{future}}(t)$47

with a distance search constrained by

$s_{\text{future}}(t)$48

The scheduler also produces an empirical bridge-and-stale-state fit of the form $s_{\text{future}}(t)$49; for the $s_{\text{future}}(t)$50 Fermi–Hubbard lattice, the reported coefficients are $s_{\text{future}}(t)$51, $s_{\text{future}}(t)$52, $s_{\text{future}}(t)$53, with $s_{\text{future}}(t)$54 (Heavey et al., 6 Mar 2026).

For the $s_{\text{future}}(t)$55 Fermi–Hubbard simulation test circuit, explicit scheduling yields a $s_{\text{future}}(t)$56 runtime speedup and a $s_{\text{future}}(t)$57 reduction in bridge- and stale-state-qubit overheads compared to the analytic model of (Caesura et al., 10 Jan 2025). The detailed comparison reports logical qubits $s_{\text{future}}(t)$58 versus $s_{\text{future}}(t)$59, time to completion $s_{\text{future}}(t)$60 s versus $s_{\text{future}}(t)$61 s, average bridge plus stale fraction $s_{\text{future}}(t)$62 versus $s_{\text{future}}(t)$63, code distance $s_{\text{future}}(t)$64 versus $s_{\text{future}}(t)$65, average memory usage fraction $s_{\text{future}}(t)$66 versus $s_{\text{future}}(t)$67, average unused qubits $s_{\text{future}}(t)$68 versus $s_{\text{future}}(t)$69, and peak reaction layers $s_{\text{future}}(t)$70. The scheduler further shows that reaction times are insignificant in runtime estimates for computers with fewer than $s_{\text{future}}(t)$71 logical qubits and that the number of reaction layers per logical cycle remains $s_{\text{future}}(t)$72 in this regime. For the $s_{\text{future}}(t)$73 Fermi–Hubbard case, the analytic resource estimate fails to find a feasible code distance, whereas the scheduler completes in approximately $s_{\text{future}}(t)$74 hours.

KernelOracle applies the past–future idea to operating-system scheduling. It collects CFS traces from a running Linux kernel with perf sched, using commands such as sudo perf sched record -- sleep 50, and trains an LSTM to predict the next scheduling event. The dataset in the main experiments comes from a single-CPU virtual machine running Ubuntu 18.04 with kernel 4.15.0-58-generic, under NGINX load generated by ab -n 1000000 -c 5 http://10.0.2.15/. The paper reports more than $s_{\text{future}}(t)$75 seconds of sustained load and $s_{\text{future}}(t)$76 unique task names. Inputs include one-hot task identities and standardized inter-schedule time differences $s_{\text{future}}(t)$77; one extreme outlier greater than $s_{\text{future}}(t)$78 s is dropped. The reported result is qualitative convergence of predicted $s_{\text{future}}(t)$79 sequences toward the real sequence’s magnitude and pattern, together with a test loss that decreases and stabilizes by epoch $s_{\text{future}}(t)$80 (Kahu, 21 May 2025).

The kernel integration discussion emphasizes that predictive augmentation must remain subordinate to CFS guardrails. Suggested deployment pathways include a userspace helper with shared memory or ring buffer, eBPF hooks, a kernel module with an embedded inference engine, or hardware offload. A blended score is proposed for tie-breaking or limited biasing,

$s_{\text{future}}(t)$81

under constraints such as maximum vruntime deviation and maximum waiting time. Fairness is monitored through

$s_{\text{future}}(t)$82

with a fallback to vanilla CFS if predictive deviation becomes excessive. The paper does not report top-1 or top-$s_{\text{future}}(t)$83 next-task accuracy, perplexity, calibration, or baselines such as Markov models; those omissions are part of the method’s current status.

6. Temporal prediction, invariance, and recurring limitations

A more abstract formulation appears in the scale-invariant temporal-memory model, which is not a scheduler in the systems sense but supplies a general predictive mechanism that can be used for scheduling decisions. The model maintains a bank of leaky integrators,

$s_{\text{future}}(t)$84

approximates inverse Laplace reconstruction to obtain a fuzzy timeline of the past, and projects this memory forward by a future lag $s_{\text{future}}(t)$85 through

$s_{\text{future}}(t)$86

Pairwise associations are learned Hebbianly and full prediction is produced as

$s_{\text{future}}(t)$87

The central claim is scale invariance: for any constant $s_{\text{future}}(t)$88, the estimated probability $s_{\text{future}}(t)$89 is invariant under joint rescaling of $s_{\text{future}}(t)$90, $s_{\text{future}}(t)$91, and $s_{\text{future}}(t)$92. The method is time-local because credit is assigned to the present event by comparing predictions before and after that event (Goh et al., 2021).

This formulation clarifies why past–future schedulers recur across otherwise unrelated domains. A scheduler can be seen as any mechanism that maintains a compressed state of the past and projects a structured estimate of the future. In some applications the projected quantity is a discrete action distribution over temporally correlated tasks; in others it is a frontier score, a future memory peak, or a hazard-like timeline over future events. The papers on renewal processes, LLM workflows, and LLM serving all rely on this principle, albeit with different state spaces and different decision rules (Goh et al., 2021, Huang et al., 8 May 2026, Gong et al., 14 Jul 2025).

Several misconceptions are addressed by the literature. First, future-aware training or scheduling is not automatically beneficial. DualRec shows that future-only training is weaker than past-only training because of inference mismatch, and that too high a regularization weight $s_{\text{future}}(t)$93 can harm performance. FATE shows that removing future planning produces the largest single performance drop, but its gains depend on calibrated state-conditional costs and reachability proxies. LightLLM shows that aggressive scheduling can achieve high current memory occupancy while still failing under SLA because future memory peaks trigger evictions. KernelOracle explicitly notes that prediction errors can cause suboptimal choices and that confidence-based gating and safe fallbacks are required (Zhang et al., 2022, Huang et al., 8 May 2026, Gong et al., 14 Jul 2025, Kahu, 21 May 2025).

Second, the future component often disappears at inference or execution time. In DualRec, only the past encoder is retained for recommendation; in dual NMT, only one directional model is used at test time; in LightLLM and FATE, the future is estimated rather than observed; and in Active Volume scheduling, future bridge roles are reserved only to enable concurrent execution in the current cycle. This suggests that “future” usually denotes a training-time, planning-time, or admission-time construct rather than direct access to unavailable information at deployment. The major costs therefore arise not from runtime access to future data but from extra model capacity, solver overhead, or the need to maintain accurate historical statistics (Zhang et al., 2022, Yan et al., 2020, Heavey et al., 6 Mar 2026, Gong et al., 14 Jul 2025).

The common limitations are correspondingly domain-specific. DualRec doubles training cost and may over-align useful asymmetries when $s_{\text{future}}(t)$94 is too large. The temporally correlated task scheduler inherits the variance of REINFORCE and can degrade when auxiliary task sets become excessively large. FATE depends on calibrated switch, transfer, and cache proxies, and heavy-tailed service-time distributions affect P95 prediction. LightLLM assumes adjacent-window stability of output-length distributions and behaves conservatively during cold start. The Active Volume scheduler assumes global logical cycles, limited reaction layers, and long-range routing. KernelOracle faces inference-latency constraints and lacks comprehensive accuracy and calibration reporting. Across all of these settings, the past–future coupling is useful precisely because present decisions have delayed effects, but the coupling must be constrained to avoid mismatch, instability, or overhead.