Online Flow Time Minimization with Gradually Revealed Jobs

TL;DR

This work studies online preemptive flow-time minimization on a single machine under gradual information revelation, where each job consists of ordered operations whose durations are revealed progressively. It introduces the operation-flow-time model and an adaptive chunk-based algorithm that gradually explores a job, forming estimable chunks and leveraging dual-fitting via a local Chunk LP. The main results prove a deterministic $O(m^2)$-competitive algorithm, with a refined bound of $O(m_1 \cdot m_2)$ that depends on instance structure, and establish tight lower bounds; a special case with uniform obligatory tests yields a 2-competitive SRPT at the operation level. The results connect to robust flow-time scheduling and demonstrate practical relevance for computing systems where information about processing times becomes available gradually during execution.

Abstract

We consider the problem of online preemptive scheduling on a single machine to minimize the total flow time. In clairvoyant scheduling, where job processing times are revealed upon arrival, the Shortest Remaining Processing Time (SRPT) algorithm is optimal. In practice, however, exact processing times are often unknown. At the opposite extreme, non-clairvoyant scheduling, in which processing times are revealed only upon completion, suffers from strong lower bounds on the competitive ratio. This motivates the study of intermediate information models. We introduce a new model in which processing times are revealed gradually during execution. Each job consists of a sequence of operations, and the processing time of an operation becomes known only after the preceding one completes. This models many scheduling scenarios that arise in computing systems. Our main result is a deterministic $O(m^2)$-competitive algorithm, where $m$ is the maximum number of operations per job. More specifically, we prove a refined competitive ratio in $O(m_1 \cdot m_2)$, where $m_1$ and $m_2$ are instance-dependent parameters describing the operation size structure. Our algorithm and analysis build on recent advancements in robust flow time minimization (SODA '26), where jobs arrive with estimated sizes. However, in our setting we have no bounded estimate on a job's processing time. Thus, we design a highly adaptive algorithm that gradually explores a job's operations while working on them, and groups them into virtual chunks whose size can be well-estimated. This is a crucial ingredient of our result and requires a much more careful analysis compared to the robust setting. We also provide lower bounds showing that our bounds are essentially best possible. For the special case of scheduling with uniform obligatory tests, we show that SRPT at the operation level is $2$-competitive, which is best possible.

Figures (2)

• Figure 1: Illustration of the decision tree model. Operations are rectangles with widths proportional to processing time. Edges are labeled with intermediate results $x_i$ that determine the length of the next operation. The blue operations are realized operations. Currently, the job is at operation $j_4$. Future operations are unknown until the preceding intermediate result is computed.
• Figure 2: Example chunk structure for a single job with $12$ operations and $3$ chunks. Each bar is an operation.

Theorems & Definitions (82)

• Theorem 1
• Theorem 2
• Theorem 3
• Theorem 4
• Theorem 4
• proof
• Theorem 5
• Theorem 5
• Definition 1: Job types
• Lemma 6