Preemptive multiprocessor order scheduling to minimize total weighted flowtime

Abstract

Consider m identical machines in parallel, each of which can produce k different product types. There is no setup cost when the machines switch from producing one product type to another. There are n orders each of which requests various quantities of the different product types. All orders are available for processing at time t = 0, and preemption is allowed. Order i has a weight w_i and its completion time is the time when its last requested product type finishes. Our goal is to find a preemptive schedule such that the total weighted completion time $\sum w_i{C}_i$ is minimized. We show that this problem is NP-hard even when all jobs have identical weights and there are only two machines. Motivated by the computational complexity of the problem, we propose a simple heuristic and show that it obeys a worst-case bound of 2 − 1/m. Finally, empirical studies show that our heuristic performs very well when compared with a lower bound of the optimal cost.

Introduction

Consider m identical machines in parallel, each of which can produce k different product types. There is no setup cost when the machines switch from producing one product type to another. There are n orders each of which requests various quantities of the different product types. All orders are available for processing at time t = 0, and preemption is allowed. Order i has a weight w_i and its completion time is the time when its last requested product type finishes. Our goal is to find a preemptive schedule such that the total weighted completion time $\sum w_i{C}_i$ is minimized.

Formally, we are given m identical and parallel machines and n orders. Order i, 1 ⩽ i ⩽ n, requests n_i (n_i ⩽ k) different product types. The processing time of the jth, 1 ⩽ j ⩽ n_i, product type requested by order i is denoted by p_i,j. We use p_i to denote the sum of the processing times; i.e., $p_i={\sum }_{j=1}^{n_i}{p}_{i\text{,}j}$. The various different product types requested by order i can be processed simultaneously on different machines. However, no single product type can be processed simultaneously by two or more machines. Order i has a weight w_i and is available for processing at time t = 0. Let S be a schedule of the n orders on the m machines, and let C_i,j(S) denote the completion time of the jth product type of order i. The completion time of order i, C_i(S), is defined to be $C_i(S)={\max }_{j=1}^{n_i}\{C_{i\text{,}j}(S)\}$. The total weighted completion time of S is $\sum w_i{C}_i(S)$. If the context is clear, we drop S from the notation. Our goal is to find a schedule S_OPT such that $\sum w_i{C}_i(S_{\text{OPT}})$ is minimized. Such a schedule will be called an optimal schedule which we always denote by S_OPT.

Order scheduling models many real-life applications. Consider a manufacturing facility that can produce different types of products. A customer can order various quantities of the different product types. For convenience in shipping and billing, it would be more desirable to ship all the products requested by the customer at the same time. Sometimes, the customer request all the products to be delivered at the same time and hence the company has no choice.

Another application can be found in a car-repair shop. Suppose a car has several broken parts that need to be fixed. The shop has several mechanics that can fix any broken part. The car will leave the shop when all the broken parts are fixed. This problem is a direct application of our model.

Another application is the production of components for subsequent assembly. Consider a production process with two stages, say fabrication and assembly. A product consists of various components that are produced in the fabrication stage. When all the required components are produced, we can assemble these components in the assembly stage. Here the fabrication stage can be represented by our model.

Order scheduling has received much attention in recent years; see [1], [2], [3], [6], [7], [8], [12], [15], [20], [21]. Julien and Magazine [8] studied a single machine problem with sequence-dependent setup time. Their goal is to minimize the total completion time $\sum C_j$. They developed a polynomial-time algorithm for two product types and when the batch processing order is fixed. Coffman et al. [3] studied a similar problem where the batch processing order is not fixed. Baker [1] studied a problem similar to Coffman et al., except that products are not available until the entire batch is finished (the so-called batch availability, see [15]). Gupta et al. [7] studied a bicriterion problem under the assumption that each order requests all k product types. Gerodimos et al. [6] studied a single machine problem with sequence-independent setup time. They studied three objectives: maximum lateness (L_max), weighted number of tardy jobs $(\sum w_i{U}_i)$, and total completion time $(\sum C_j)$. Most of the results are in the form of NP-hardness proofs, polynomial-time algorithms, and pseudo-polynomial algorithms. They posed as open question the complexity of minimizing the total completion time. Recently, Ng et al. [12] answered the question in the negative, showing that the problem is unary NP-hard.

In the literature relatively few work have been done on parallel machines. Blocher and Chhajed [2] and Yang and Posner [21] studied the problem of minimizing total completion time on m identical and parallel machines, assuming that there is no setup time when the machines switch from producing one product type to another. Their studies are restricted to nonpreemptive scheduling discipline only. Blocher and Chhajed [2] showed that the problem is NP-hard for two machines and proposed several simple heuristics. Several lower bounds were derived which were used to compare with the performance of the proposed heuristics in an empirical study. Yang and Posner [21] proposed one heuristic and showed that it obeys a worst-case bound of 2 − 1/m. They gave two more heuristics and showed that on two machines they obey a worst-case bound of 6/5 and 9/7, respectively. They conjectured that the composite algorithm obeys a worst-case bound of 7/6, see [20].

Another line of research related to our work is that of order scheduling on dedicated machines. In this model, there are m ⩾ 1 dedicated machines, each of which is capable of producing one and only one product type. There are n orders and each order requests n_i (n_i ⩽ m) different product types. The objective is to minimize $\sum C_j$. Leung et al. [10] denote this problem as $\mathit{PDm}||\sum C_j$. Wagneur and Sriskandarajah [18] presented a proof claiming that $\mathit{PD}2\Vert \sum C_j$ is strongly NP-hard. Unfortunately, their proof is not correct; see Leung et al. [11]. Independently, Sung and Yoon [17] showed that $\mathit{PD}2\Vert \sum w_j{C}_j$ is strongly NP-hard. Leung et al. [10] later showed that $\mathit{PD}3\Vert \sum C_j$ is strongly NP-hard. Finally, Roemer [13] showed that $\mathit{PD}2\Vert \sum C_j$ is indeed strongly NP-hard.

Several heuristics have been proposed in the literature for the $\mathit{PDm}\Vert \sum C_j$ problem. Wang and Cheng [19] analyzed three greedy heuristics whose worst-case bounds are m. Two of these heuristics were generalizations of the heuristics proposed by Sung and Yoon [17] for two machines. Leung et al. [10] proposed two new heuristics and showed empirically that one of the heuristics have consistently outperform the three heuristics that have appeared in the literature.

Our work differs from the work of [2], [21] in that we study preemptive scheduling (rather than nonpreemptive scheduling) and our objective function is total weighted completion time $\sum w_i{C}_i$ (rather than total completion time $\sum C_i$).

In the following section we will show that our problem is NP-hard, even when there are two machines and two product types, and each order requests both product types and has the same weight. In Section 3 we will propose a fast heuristic and show that it obeys a bound of 2 − 1/m. In Section 4 we perform a computational experiment. Empirical studies show that our heuristic performs very well when compared with a lower bound of the optimal cost. Finally, we draw some concluding remarks in the last section.