Fixed-Order Scheduling on Parallel Machines

Abstract

We consider the following natural scheduling problem: Given a sequence of jobs with weights and processing times, one needs to assign each job to one of m identical machines in order to minimize the sum of weighted completion times. The twist is that for machine the jobs assigned to it must obey the order of the input sequence, as is the case in multi-server queuing systems. We establish a constant factor approximation algorithm for this (strongly NP-hard) problem. Our approach is necessarily very different from what has been used for similar scheduling problems without the fixed-order assumption. We also give a QPTAS for the special case of unit processing times.

This work was partially supported by the Netherlands Organisation for Scientific Research (NWO) through a VIDI grant (016.Vidi.189.087) and the Gravitation Programme Networks (024.002.003).

A A QPTAS for unit processing times

In this section we sketch a simple quasipolynomial time approximation scheme (QPTAS) for the problem under unit processing times. Note that we do not know if this version of the problem remains NP-hard. However, it seems to capture most of the difficulty, so we feel that tackling this case will help substantially in improving the upper bound for the general case. The QPTAS works by solving a relaxed problem by dynamic programming. We round the completion times to geometric intervals and then we consider schedules in which at any time point only one machine per completion time can accept jobs. This sufficiently reduces the solution space to get a quasipolynomial time algorithm.

The first step is to consider only a logarithmic number of distinct completion times. Let $R = \{ \lfloor (1+\epsilon )^{i} \rfloor : i\in \mathbb {N}\}$ be the set of integers found by rounding down a geometric series growing with rate $1+\epsilon$. Then order the elements $1=R_1<R_2<\dots$ and take $R_0 = 0$ by convention. Assume that s is the smallest index such that $R_s\ge n$, and note that $s = O(\log _{1+\epsilon }(n))$. Now consider the objective of minimizing the weighted sum of rounded completion times, where each completion time is rounded up to the nearest $R_i$. Call this the rounded objective; clearly the rounded objective of any schedule is at most $1+\epsilon$ times the actual objective. So, if we can find an optimal segmented schedule for the rounded objective, we immediately get a $(1+\epsilon )$-approximation to the original problem.

Now we define a restricted type of schedule, which we call a segmented staircase schedule. A segmented staircase schedule is similar to a staircase shaped schedule, except that the “steps” are now defined in terms of the rounded completion times. When j is assigned to a machine, it is assigned to the leftmost machine that gives it the same rounded completion time. In other words, if a job j gets assigned to $\mu (j)$ and gets completed at time $t\in (R_i, R_{i+1}]$, then $\mu (j)$ is the lowest index machine for which the number of jobs $k<j$ assigned to it does not exceed $R_{i+1}-1$.

Lemma 7

There is an optimal solution to the problem of minimizing the rounded objective that is a segmented staircase schedule.

Proof

Take $\mu$ to be a schedule for which $(\mu (1), \mu (2), \ldots , \mu (n))$ is lexicographically minimal amongst all solutions that are optimal for the rounded objective. Notice that $\mu$ must be staircase shaped; otherwise, transforming it into a staircase shaped schedule would yield a schedule $\mu '$ in which every job has the same completion time, but which is lexicographically smaller than $\mu$.

Suppose for a contradiction that this schedule is not a segmented staircase schedule. Let j be the last (maximum index) job that violates the rule for a segmented staircase schedule: j is assigned to machine $h'$, but $h < h'$ is the smallest index machine that gives it the same rounded completion time, ignoring all jobs after j. Let k be the first job $k>j$ scheduled on machine h. (If there is no such job, then moving j to $h'$ reduces the lexicographical value and does not increase the total rounded completion time.) Note that since j was chosen maximally, no job $\ell$ with $j<\ell <k$ is scheduled on machine $h'$. Moreover, $\sigma _\mu (k) > \sigma _\mu (j)$, since $\mu$ is staircase shaped, so it must be that j and k are both in the same segment $(R_i, R_{i+1}]$ for some i. So we can simply swap k and j to obtain a lexicographically smaller schedule of the same rounded objective value.

For segmented staircase schedules, we can compactly describe the loads on the machines just prior to assigning job j. Let $X^j_i$ be the number of jobs on machines with load currently in the interval $[R_i, R_{i+1})$ just prior to assigning job j. Since only one of the machines with load in that interval can have strictly more than $R_i$ jobs on it, this number also completely determines how many machines there are with loads exactly $R_i$. For each j, we have $n^{O(\log _{1 + \epsilon }n )}$ options for the values of $X^j_1,X^j_2,\ldots ,X^j_s$. Once we know the minimum cost of a schedule attaining each of those options, we can compute the cost of all the schedules up to job $j+1$. Hence, we get the main result of this section.

Theorem 3

For any $\epsilon > 0$, there is a $(1+\epsilon )$-approximation algorithm for fixed-order scheduling with unit processing times with running time $n^{O(\log _{1+\epsilon } n)}$.