SmartFill: Optimal Scheduling Under Concave Speedups

• SmartFill is an optimal scheduling algorithm that allocates resources across parallel jobs with arbitrary concave speedup functions to minimize weighted completion times.
• It employs the Consistent Derivative Ratio (CDR) Rule to equate marginal gains between jobs, reducing the search space for optimal schedules.
• The algorithm integrates a General Water-Filling method and a recursive scheduling procedure, resulting in lower mean slowdowns and improved completion metrics.

SmartFill is an optimal scheduling algorithm for parallel jobs under general concave speedup functions. It addresses the problem of allocating a total resource budget $B$ across $M$ jobs with sizes $x_i$, where allocating more resources to a job accelerates its completion but with diminishing returns, and the objective is to minimize a weighted sum of job completion times, $J=\sum_{i=1}^M w_i T_i$. The algorithm is developed in the context of a previously open problem: prior work, heSRPT, solved only some specific speedup functions with an exponential form, whereas SmartFill is designed for arbitrary concave speedup functions and combines a structural optimality condition, the Consistent Derivative Ratio (CDR) Rule, with the General Water-Filling (GWF) method to compute optimal allocations (Li et al., 1 Sep 2025).

1. Problem setting and optimization objective

The SmartFill framework considers $M$ jobs with sizes $x_i$, a speedup function $s(\theta)$, and a total resource budget $B$. The speedup function is assumed to be strictly increasing, strictly concave, and smooth. At each time $t$, the scheduler assigns a fraction $\theta_i(t)$ to each job $M$0, subject to the feasibility constraint

$M$1

The optimization target is to minimize the weighted sum of job completion times,

$M$2

where $M$3 denotes the completion time of job $M$4 (Li et al., 1 Sep 2025).

This formulation captures the setting in which additional computation resources improve performance but only with diminishing returns. The paper positions this as a fundamental problem in cloud and edge computing systems for AI-based applications. A plausible implication is that the model is intended to cover workloads whose parallel scaling behavior is not well approximated by a single power-law or exponential family, which motivates the move from heSRPT to a method that works for arbitrary concave speedup functions.

2. Consistent Derivative Ratio rule

The central structural result underlying SmartFill is the Consistent Derivative Ratio Rule. For the optimal allocation $M$5, for any two active jobs $M$6 and $M$7, the ratio of the derivatives of the speedup functions remains constant in time: $M$8 for some constant $M$9, over all times at which both jobs receive a positive allocation. The associated corollary states that there exist constants $x_i$0 such that

$x_i$1

In words, the relative marginal gain of resource across jobs is pinned throughout the scheduling (Li et al., 1 Sep 2025).

The CDR Rule significantly reduces the search space for optimal schedules because only policies satisfying this property need to be considered. It also changes the qualitative picture of optimal scheduling outside the heSRPT regime. For non-power-law speedups, it may be optimal to give zero resource to some jobs at some times, rather than allocating resources to all active jobs. This is one of the main conceptual distinctions between SmartFill and heSRPT.

A common misconception, inherited from intuition built around heSRPT, is that an optimal scheduler should always allocate positive resources to every active job. The SmartFill analysis rejects that conclusion in the general concave case. Specifically, when $x_i$2, the optimal policy can set some $x_i$3 to zero during some time windows. This selective behavior is not a heuristic add-on; it follows from the derivative-ratio structure and the zero-allocation thresholds built into the constrained allocation problem (Li et al., 1 Sep 2025).

3. General Water-Filling method

To operationalize the CDR Rule, the paper introduces the General Water-Filling method. GWF solves a constrained allocation problem for $x_i$4 jobs with constants $x_i$5, seeking allocations $x_i$6 with total resource $x_i$7 such that

$x_i$8

$x_i$9

and, for $J=\sum_{i=1}^M w_i T_i$0, if $J=\sum_{i=1}^M w_i T_i$1,

$J=\sum_{i=1}^M w_i T_i$2

while if $J=\sum_{i=1}^M w_i T_i$3 and $J=\sum_{i=1}^M w_i T_i$4,

$J=\sum_{i=1}^M w_i T_i$5

These conditions encode both the CDR property and the threshold behavior associated with zero allocation (Li et al., 1 Sep 2025).

The method introduces a suitable auxiliary strictly decreasing function $J=\sum_{i=1}^M w_i T_i$6, and defines for each job

$J=\sum_{i=1}^M w_i T_i$7

The total allocated resource is then

$J=\sum_{i=1}^M w_i T_i$8

and the water level $J=\sum_{i=1}^M w_i T_i$9 is chosen so that $M$0 (Li et al., 1 Sep 2025).

The paper’s intuition is that the procedure is like pouring water into non-identical bottles, each bottle’s shape determined by $M$1 and the $M$2 tradeoff, raising the level $M$3 until the total water meets the resource limit. In algorithmic terms, one selects $M$4 so that $M$5 is tractable and $M$6 is strictly decreasing, evaluates $M$7, computes the sum, and adjusts $M$8, for example via bisection, until the sum matches $M$9. For non-regular cases, each constrained allocation subproblem can be solved in $x_i$0 time, where $x_i$1 is the number of jobs and $x_i$2 is the search granularity (Li et al., 1 Sep 2025).

4. SmartFill algorithm and schedule representation

SmartFill builds a full schedule recursively from constrained allocation subproblems. The schedule is divided into phases: phase $x_i$3 is between the $x_i$4-th and $x_i$5-th job completing. In phase $x_i$6, the set of active jobs is $x_i$7, with allocations $x_i$8. The schedule is represented as an upper-triangular matrix $x_i$9 (Li et al., 1 Sep 2025).

Initialization begins with the last-job case: $s(\theta)$0 The algorithm then iterates upward for $s(\theta)$1. First, it determines the allocation for the next job: $s(\theta)$2 Second, it allocates the remaining budget to jobs $s(\theta)$3: $s(\theta)$4 Third, it updates the constants

$s(\theta)$5

and

$s(\theta)$6

This procedure is repeated until all jobs are allocated (Li et al., 1 Sep 2025).

The paper also presents the following pseudocode:

$M$01

Its total complexity is $s(\theta)$7, because there are $s(\theta)$8 phases and each CAP is $s(\theta)$9 (Li et al., 1 Sep 2025).

5. Regular and non-regular speedup functions

The paper distinguishes between regular and non-regular speedup functions. A speedup is regular if

$B$0

for constants $B$1, $B$2, and $B$3. Common cases include $B$4, $B$5, for which $B$6, and $B$7. In the regular case,

$B$8

As a result, $B$9 becomes a piecewise-linear, affine function of $t$0, and the water-filling step reduces to solving a piecewise-linear equation, which yields a closed-form solution (Li et al., 1 Sep 2025).

For $t$1, the solution coincides with heSRPT. This establishes that SmartFill contains the heSRPT allocation pattern as a special case rather than replacing it with an incompatible construction. The paper also states that closed-form solvability generally occurs when $t$2 and the corresponding sum equations are algebraically tractable, including polynomial, exponential, or log-like regular forms (Li et al., 1 Sep 2025).

For non-regular functions, the GWF framework still applies. When $t$3 has no closed form, as with composite or more complex concave functions, the method uses numeric search, for example bisection on $t$4, and each evaluation computes $t$5 numerically if necessary. This suggests that the main divide in the framework is not one of optimality but one of symbolic tractability: regular forms admit closed-form algebraic schedules, while non-regular forms require numerical inversion and search.

6. Selective allocation, relation to heSRPT, and reported results

The most visible operational difference from heSRPT is selective resource allocation. For $t$6 with $t$7, heSRPT always allocates positive resource to every job at all times because $t$8, so it is never optimal to starve a job. By contrast, SmartFill can, and will, set some $t$9 to zero during some time windows when $\theta_i(t)$0, because allocating resource to those jobs would not yield sufficient benefit under the CDR Rule (Li et al., 1 Sep 2025).

The paper reports both theoretical and numerical results. SmartFill exactly matches heSRPT when $\theta_i(t)$1. It is stated to be optimal for all regular and, numerically, for non-regular cases, with no optimality gap. In general concave $\theta_i(t)$2, SmartFill yields lower mean slowdown and completion times than approximate heSRPT extensions because it can focus resources better (Li et al., 1 Sep 2025).

The numerical examples given in the paper include two explicit comparisons at $\theta_i(t)$3 jobs. For $\theta_i(t)$4, SmartFill reduces mean slowdown by $\theta_i(t)$5. For $\theta_i(t)$6, it produces a $\theta_i(t)$7 lowering compared to “heSRPT with best-fit $\theta_i(t)$8” (Li et al., 1 Sep 2025).

The paper further states that the CDR Rule is conjectured to apply to even more general settings, including different speedup per job and time-varying resources, although SmartFill as presented applies only to the uniform, fixed-resource, uniform speedup case. This conjecture is explicitly framed as a generalization rather than a proved extension.

7. Significance and interpretive context

Within the paper’s framing, SmartFill generalizes prior solutions by providing an optimal method for arbitrary concave speedup functions rather than only for special functional forms. It also preserves closed-form solutions when possible and remains computationally efficient through a polynomial-time numerical procedure when closed form is unavailable. Its computational profile is summarized as numerically robust with complexity $\theta_i(t)$9 (Li et al., 1 Sep 2025).

The key conceptual contribution is the synthesis of three ingredients: the CDR Rule as a structural characterization of optimal schedules, GWF as the mechanism for solving the constrained allocation problem implied by that structure, and the recursive SmartFill construction that assembles phase-by-phase optimal allocations. This suggests a unifying perspective in which parallel scheduling under concave speedup is governed by relative marginality rather than by unconditional sharing across all active jobs.

A further implication is methodological. Because SmartFill selectively concentrates resource when the speedup curve does not strongly favor “everybody gets a bit,” it replaces a blanket all-jobs-active intuition with a thresholded marginal-gain criterion. In that sense, its significance lies not only in extending the range of admissible speedup functions, but also in changing the qualitative form of optimal schedules under finite $M$00 (Li et al., 1 Sep 2025).