Streaming Approximation Scheme for Minimizing Total Completion Time on Parallel Machines Subject to Varying Processing Capacity

Formally our scheduling model can be defined as follows. There is a set $N=\{1,\cdots,n\}$ of $n$ jobs and $m$ parallel machines where the processing capacity of machines varies over time. Each job $j\in N$ has a processing time $p_{j}$ and can be processed by any one of the machines uninterruptedly. Associated with each machine $M_{i}$ are $l_{i}$ continuous intervals during which the processing capacity of $M_{i}$ are $\alpha_{i,1}$, $\alpha_{i,2}$, $\ldots$, $\alpha_{i,l_{i}}$, respectively, see Figure 1 for an example.

If the machine $M_{i}$ has full availability during an interval, we say the machine’s processing capacity is $1$ and a job, $j$, can be completed in $p_{j}$ time units; otherwise, if the machine $M_{i}$’s processing capacity is less than $1$, for example $\alpha$, then $j$ can be completed in $p_{j}/\alpha$ time units.

The objective is to minimize the total completion time of all jobs. For any schedule $S$, let $C_{j}(S)$ be the completion time of the job $j$ in $S$. If the context is clear, we use $C_{j}$ for short. The total completion time of the schedule $S$ is $\sum_{1\leq j\leq n}C_{j}$.

In this paper, we study our scheduling problem under data stream model. The goal is to design streaming algorithms to approximate the optimal solution in a limited number of passes over the data and using limited space. Using the three-field notation introduced by Graham et al. [11], our problem is denoted as $P_{m},\alpha_{i,k}\mid stream\mid\sum C_{j}$; if for all intervals, the processing capacity is greater than or equal to a constant $\alpha_{0}$, $0<\alpha_{0}\leq 1$, our problem is denoted as $P_{m},\alpha_{i,k}\geq\alpha_{0}\mid stream\mid\sum C_{j}$.

We first review the related work under the traditional data model. The first related work is done by Baker and Nuttle [4] in 1980. They studied the problems of sequencing $n$ jobs for processing by a single resource to minimize a function of job completion times subject to the constraint that the availability of the resource varies over time. Their work showed that a number of well-known results for classical single-machine problems can be applied with little or no modification to the corresponding variable-resource problems. Adiri and Yehudai [1] studied the problem on single and parallel machines with the restrictions such that if a job is being processed, the service rate of a machine remains constant and the service rate can be changed only when the job is completed. In 1992, Hirayama and Kijima [13] studied this problem on single machine where the machine capacity varies stochastically over time.

In 2016, Hall et. al. in [12] studied similar problems in multitasking environment, where a machine does not always have the full capacity for processing primary jobs due to previously scheduled routine jobs. In their work, they assume there is a single machine whose processing capacity is either 1 or a constant $e$ during an interval. They showed that the total completion time can be minimized by scheduling the jobs in non-decreasing order of the processing time, but it is unary NP-Hard for the objective function of total weighted completion time.

Another widely studied model is scheduling subject to machine unavailability constraint where the machine has either full capacity, or zero capacity so no jobs can be processed. Various performance criteria and machine environments have been studied under this model, see the survey papers [19] and [15] and the references therein. Among the results, for the objective of minimizing total completion time on parallel machines, the problem is NP-hard.

Other scheduling models with varying processing capacity are also studied in the literature where variation of machine availability are related with the jobs that have been scheduled. These models include scheduling with learning effects (see the survey paper [14] by Janiak et al. and the references therein), scheduling with deteriorating effects (see the paper [5] by Cheng et al.), and interdependent processing capacitys (see the paper [2] by Alidaee et al. and the references therein), etc.

In our model, there are multiple machines, the processing capacity of each machine can change between 0 and 1 from interval to interval and the capacity change can happen while a job is being processed. The goal is to find a schedule to minimize total completion time. In [9] we have showed that there is no polynomial time approximation algorithm unless $P=NP$ if the processing capacities are arbitrary for all machines. Then for the problem where the sharing ratios on some machines have a constant lower bound, we analyzed the performance of some classical scheduling algorithms and developed a polynomial time approximation scheme when the number of machines is a constant.

We now review the related work under the data stream model. Since the streaming algorithm model was formally established by Alon, Matias, and Szegedy in  [3], it has received a lot of attention. While streaming algorithms have been studied in the field of statistics, optimization, and graph algorithms (see surveys by Muthukrishnan [18] and McGregor [16]) and some research results have been obtained, very limited research on streaming algorithms ([6] [10]) has been done in the field of sequencing and scheduling so far. For the proposed model, in [10] we developed a streaming algorithm for the problem with the objective of makespan minimization.

In this paper, we present the first efficient streaming algorithm for the problem $P_{m},\alpha_{i,k}\geq\alpha_{0}\mid stream\mid\sum C_{j}$ . Our streaming algorithm can compute an approximation of the optimal value of the total completion time in one pass, and output a schedule that approximates the optimal schedule in two passes.

In this step we read the job input stream $N=\{i:1\leq i\leq n\}$ and generate a sketch of $N$ using rounding technique. The idea of the procedure in this stage is to split the jobs into large jobs and small jobs and round the processing time of the large jobs so that the number of distinct processing times is reduced. Specifically, the sketch is a set of pairs where each pair contains a rounded processing time and the number of jobs with this rounded processing time. Let $p_{max}=\max_{j\in N}{p_{j}}$. The sketch of $N$ can be formally defined as follows:

When $n$ and $p_{max}$ are known before reading the job stream, one can generate the sketch from the job input stream with the following simple procedure: Whenever a job $j$ is read, if it is a small job, skip it and continue. Otherwise, it is a large job. Suppose that $p_{j}\in[(1+\tau)^{k-1},(1+\tau)^{k})$, we update the pair $(rp_{k},n_{k})$ by increasing $n_{k}$ by 1, where $rp_{k}=\left\lfloor(1+\tau)^{k}\right\rfloor$.

In reality, however, $n$ and $p_{max}$ may not be obtained accurately without scanning all the jobs. Meanwhile, in many practical scenarios, the estimation of $n$ and $p_{max}$ could be obtained based on priori knowledge. Specifically, an upper bound of $n$, $n^{\prime}$, could be given such that $n\leq n^{\prime}\leq c_{1}n$ for some $c_{1}\geq 1$; and a lower bound of $p_{max}$, $p^{\prime}_{max}$, could be given such that $1\leq p_{max}^{\prime}\leq p_{max}\leq c_{2}p_{max}^{\prime}$ for some $c_{2}\geq 1$. Depending on whether $n^{\prime}$ and $p^{\prime}_{max}$ are known beforehand, we have four cases: (1) both $n^{\prime}$ and $p^{\prime}_{max}$ are known; (2) only $p^{\prime}_{max}$ is known; (3) only $n^{\prime}$ is known; (4) neither $n^{\prime}$ nor $p^{\prime}_{max}$ is known.

For all four cases, we can follow the same procedure below to get the sketch of the job input stream. The main idea is as we read each job $j$, we dynamically update the maximum processing time, $p_{curMax}$, the total number of jobs, $n_{cur}$, the threshold of processing time for large jobs, $p_{minL}$, and the sketch if needed. For convenience, in the following procedure we treat $\infty$ as a number, and $1/\infty$ as $0$.

1. 1.

   Let $\tau=\tfrac{\epsilon\alpha_{0}}{15}$

2. 2.

   if $n^{\prime}$ is not given, set $n^{\prime}=\infty$

3. 3.

   if $p^{\prime}_{max}$ is not given, set $p^{\prime}_{max}=1$

4. 4.

   $p_{minL}=\max\{\tfrac{\epsilon\alpha_{0}}{3(n^{\prime})^{2}}p^{\prime}_{max},1\}$,

5. 5.

   Initialize $p_{curMax}=0$, $n_{cur}=0$, and $N^{\prime\prime}_{L}=\emptyset$

6. 6.

   Construct $N^{\prime\prime}_{L}$ while repeatedly reading next $p_{j}$

   1. 6.a.

      $n_{cur}=n_{cur}+1$

   2. 6.b.

      If $p_{j}>p_{curMax}$

   3. $p_{curMax}=p_{j}$

   4. if $p_{minL}<\tfrac{\epsilon\alpha_{0}}{3(n^{\prime})^{2}}\cdot p_{curMax}$, $p_{minL}=\tfrac{\epsilon\alpha_{0}}{3(n^{\prime})^{2}}\cdot p_{curMax}$

   5. 6.c.

      If $p_{j}\geq p_{minL}$

      1. 6.c.1

         $rp=\left\lfloor(1+\tau)^{k}\right\rfloor$ where $p_{j}\in[(1+\tau)^{k-1},(1+\tau)^{k})$

      2. 6.c.2

         if there is a tuple $(rp_{k},n_{k})\in N^{\prime\prime}_{L}$ where $rp_{k}=rp$,

      3. 6.c.3

         then update $n_{k}=n_{k}+1$

      4. 6.c.4

         else

      5. $N^{\prime\prime}_{L}=N^{\prime\prime}_{L}\cup\{(rp,1)\}$

7. 7.

   $p_{max}=p_{curMax}$, $n=n_{cur}$, $p_{minL}=\tfrac{\epsilon\alpha_{0}}{3n^{2}}p_{max}$

8. 8.

   Let $N^{\prime}_{L}=\{(rp_{k},n_{k}):(rp_{k},n_{k})\in N^{\prime\prime}_{L},\text{ and }rp_{k}>p_{minL}\}$

While the above procedure can be used for all four cases, we need different data structures and implementations in each case to achieve time and space efficiency. For cases (1) and (2) where $p^{\prime}_{max}$ is known, since $1\leq p_{max}^{\prime}\leq p_{max}\leq c_{2}p_{max}^{\prime}$ for some constant $c_{2}$, there are at most $\log_{1+\tau}{c_{2}p^{\prime}_{max}}$ distinct rounded processing times, and thus we can use an array to store $N^{\prime\prime}_{L}$. For cases (3) and (4) where no information about $p^{\prime}_{max}$ is known, we can use a B-tree to store the elements of $N^{\prime\prime}_{L}$. Each node in the tree corresponds to an element $(rp_{k},n_{k})$ with $rp_{k}$ as the key. With $p_{curMax}$ being dynamically updated, there are at most $\log_{1+\tau}{p_{curMax}}$ distinct rounded processing times, and thus at most $\log_{1+\tau}{p_{curMax}}$ nodes in the B-tree at any time. As each job $j$ is read in, we may need to insert a new node to B-tree. If $p_{j}>p_{curMax}$, $p_{curMax}$ needs to be updated and so does $p_{minL}$, which is the threshold of processing time for large jobs. Hence the nodes with the key less than $p_{minL}$ should be removed. To minimize the worst case update time for each job, each time when a new node is inserted, we would delete the node with the smallest key if it is less than $p_{minL}$.

The following lemma gives the space and time complexity for computing sketch $N^{\prime}_{L}$ from the job input stream for all four cases.

In this stage, we will find an approximate value of the minimum total completion time for our scheduling problem based on the sketch $N^{\prime}_{L}=\{(rp_{k},n_{k}):k_{0}\leq k\leq k_{1}\}$ that is obtained from the first stage. The idea is to assign large jobs in the sketch $N^{\prime}_{L}$ group by group in SPT order to $m$ machines where group $k$, $k_{0}\leq k\leq k_{1}$, corresponds to pair $(rp_{k},n_{k})$ in sketch $N^{\prime}_{L}$. After all groups of jobs are scheduled, we find the minimum total completion time among the remaining schedules, and return an approximate value.

To schedule each group of jobs, we perform two operations:

• Enumerate: enumerate all assignments of the jobs in the group to $m$ machines that satisfy certain property, and

• Prune: prune the schedules so that only a limited number of schedules are kept.

During the Enumerate operation, we enumerate the assignments of $n_{k}$ jobs from group $k$ to $m$ machines using $(\delta,m)$-partition as defined below.

For example, for $\delta=1$, to schedule a group of $b=9$ jobs to $m=3$ machines, we enumerate those assignments corresponding to $(1,3)$-partitions of $9$. From the definition, some examples of $(1,3)$-partitions of 9 are $\{2,2,5\}$, $\{0,9,0\}$, $\{0,1,8\}$. Corresponding to the partition $\{2,2,5\}$, we schedule 2 jobs on the first machine, 2 jobs on the second machine and the remaining 5 jobs on the last machine. By definition, $\{2,2,5\}$ and $\{2,5,2\}$ are two different partitions corresponding to two different schedules.

During the Prune operation, we remove some schedules so that only a limited number of schedules are kept. Let $S$ be a schedule of the jobs on $m$ machines, we use $P_{i}(S)$ to denote the total processing time of the jobs assigned to machine $M_{i}$ in $S$; and use $\sigma_{i}(S)$ to denote the total completion time of the jobs scheduled to $M_{i}$ in $S$. The schedules are pruned so that no two schedules are “similar”, where “similar” schedules are defined as follows.

Our complete algorithm for stage 2 is formally presented below in which the Enumerate and Prune operations are performed in Step (3.3.b) and (3.3.c), respectively.

Before we analyze the performance of the above procedure, we first consider a special case of our scheduling problem: all jobs have equal processing time and there is a single machine that has the processing capacity at least $\alpha_{0}$ at any time. Suppose that the jobs are continuously scheduled on the machine. The following lemma shows how the total completion time of these jobs changes if we shift the starting time of these jobs and/or insert additionally a small number of identical jobs at the end of these jobs.

Now we analyze the performance of our algorithm. In step 3.3.b, we only consider the schedules of the $n_{k}$ jobs corresponding to $(\delta,m)$-partitions. Let $S$ be any schedule of the jobs in sketch $N^{\prime}_{L}$, we will show that at the end of step 3.3.b there is a schedule $S_{\delta}\in U_{k}$ that is $\delta_{k}$-close to $S$. Let $n_{i,k}(S)$ be the number of jobs from group $k$ that are scheduled on machine $M_{i}$ in $S$. The $\delta_{k}$-close schedule to $S$ is defined as follows.

The following lemma shows that there is always a schedule $S_{\delta}\in U_{k}$ at the end of step 3.3.b that is $\delta_{k}$-close to $S$.

We now analyze step 3.3.c of our algorithm where “similar” schedules are pruned after a group of jobs in $N^{\prime}_{L}$ are scheduled. We will need the following notations:

For any optimal schedule $S^{*}$ of the jobs in $N^{\prime}_{L}$, let $S_{k}^{*}$ be the partial schedule of jobs from groups $k_{0}$ to $k$ with the processing time at most $rp_{k}$ in $S^{*}$. Our next lemma shows that there is a schedule $S_{k}\in U_{k}$ that approximates the partial schedule $S_{k}^{*}$.