Scheduling for Parallel Dedicated Machines with a Single Server

Transcription

1 Scheduling for Parallel Dedicated Machines with a Single Server Celia A. Glass, 1 Yakov M. Shafransky, 2 Vitaly A. Strusevich 3 1 City University, London, United Kingdom 2 Institute of Engineering Cybernetics, National Academy of Sciences of Belarus, Minsk, Republic of Belarus 3 University of Greenwich, London, United Kingdom Received August 1998; revised October 1999; accepted October 22, 1999 Abstract: This paper examines scheduling problems in which the setup phase of each operation needs to be attended by a single server, common for all jobs and different from the processing machines. The objective in each situation is to minimize the makespan. For the processing system consisting of two parallel dedicated machines we prove that the problem of finding an optimal schedule is NP-hard in the strong sense even if all setup times are equal or if all processing times are equal. For the case of m parallel dedicated machines, a simple greedy algorithm is shown to create a schedule with the makespan that is at most twice the optimum value. For the two machine case, an improved heuristic guarantees a tight worst-case ratio of 3/2. We also describe several polynomially solvable cases of the later problem. The two-machine flow shop and the open shop problems with a single server are also shown to be NP-hard in the strong sense. However, we reduce the two-machine flow shop no-wait problem with a single server to the Gilmore Gomory traveling salesman problem and solve it in polynomial time. c 2000 John Wiley & Sons, Inc. Naval Research Logistics 47: , 2000 Keywords: scheduling; parallel dedicated machines; single server; complexity; approximation 1. INTRODUCTION Scheduling models that allow the handling of pre-operational work (the setup) have been of major interest for some decades because of their practical relevance and theoretical impact. Modern computing and manufacturing processes provide a continuous supply of new models with various types of setups. Such problems may appear to be tractable by the extensions of classical methods and algorithms, while in many other cases new specialized techniques have to be developed. In this paper, we study scheduling models with an additional constraint on the setups. Using the traditional terminology, we have a collection of jobs to be performed on one or all of several given machines. Each operation of a job on a machine consists of two phases: the setup phase and the processing phase. In our models, it is required that the setup phase of any operation is attended by a single server, which is different from any of the processing machines. In all problems considered in this paper the objective is to minimize the makespan, i.e., the maximum completion time of Correspondence to: C. A. Glass c 2000 John Wiley & Sons, Inc.

2 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 305 all jobs on all machines. The mathematical interest of these problems lies in the interlacing of scheduling considerations of the machines and the server. Models having these features are common in network computing. In the most typical situation, the network server sets up the workstations by loading the required software. In the context of parallel computing, the analogous feature is data transfer when farming operations from a central processor to slave processors. In production applications, the setting up of machines involves simultaneous use of a common resource which might be a robot or a human operator attending each setup. We analyze problems with various machine environments. Our main focus is on the simplest configuration consisting of parallel machines each dedicated to its own set of preassigned jobs. For parallel dedicated machines we establish that arising problems are NP-hard in the strong sense even for two machines. This complements a previous result by Hall et al. [11] for the case of (undedicated) parallel machines. We also demonstrate that these complexity results carry over to multistage models of flow shop and open shop. Having established that we cannot expect to solve any of the general problems to optimality in reasonable time, we concentrate on two realistic goals. These goals are: (i) to develop polynomial time approximation algorithms which guarantee a solution close to the optimum and (ii) to find special cases which are tractable in polynomial time. The remainder of this paper is organized as follows. We start by formalizing our scheduling model in Section 2 and giving a short overview of related models and results in the literature in Section 3. Then in Section 4 we examine the computational complexity of the scheduling problem with parallel dedicated machines and a single server. For that model, approximation algorithms are presented in the following two sections for the general case and for the two machine case, respectively. Their worst-case performance ratio bounds are shown to be 2 and 3/2, respectively. Several polynomially solvable cases of our parallel machine scheduling problem are described in Section 7. In Section 8 we turn to the flow shop and open shop scheduling problems with a single server. In particular, we adapt the Gilmore Gomory traveling salesman algorithm for solving the two-machine flow shop problem with no-wait in process, i.e., when no delay is allowed between the processing of a job on the machines. Concluding remarks are given in Section THE MODEL This section is devoted to formalizing our model. We first specify the precise problem which we are addressing and give relevant definitions and notation. Then we recall and extend standard three field scheduling notation which provides a succinct way of referring to individual types of problems. Formally, we are given a set N = {J 1,J 2,...,J n } of jobs, several processing machines M 1,M 2,...,M m and a single server M S. For an operation O ij of performing job J j on machine M i, the setup phase takes s ij 0 time units and is followed by the processing phase that lasts p ij 0 time units. Once the setup of some operation is completed, the machine starts the processing phase of that operation, possibly after some idle time. There is no preemption in performing any phase of any operation. A job can be assigned to at most one processing machine at a time, and no machine deals with more than one job at a time. Moreover, during the setup phase of an operation O ij both machine M i and the server M S can only perform the setup of job J j on machine M i. We consider several scheduling models sharing the features described above. Our main model assumes that the processing machines are parallel and dedicated. This implies that each job consists of exactly one operation and that the set N of jobs is in advance partitioned into m

3 306 Naval Research Logistics, Vol. 47 (2000) Table 1. An instance of the problem with three dedicated machines Job Machine Setup Time Processing Time J 1 M 1 s 11 =1 p 11 =3 J 2 M 2 s 22 =2 p 22 =2 J 3 M 3 s 33 =2 p 22 =2 J 1 M 1 s 14 =1 p 14 =1 subsets, N 1,N 2,...,N m, so that the jobs of set N i and only these are processed on machine M i, 1 i m. Table 1 presents an instance of the problem with three parallel dedicated machines. A feasible schedule for the instance is shown in Figure 1. In this figure and in the figures to follow, the setups are shown as double-framed bars. The model with parallel dedicated machines is essentially a single-stage model. Still, it can be related to some multistage models, such as the flow shop and the open shop. In these models, each job has to be processed on all machines M i,i =1, 2,...,n. In the case of the flow shop, all jobs have the same processing route, i.e., they pass through the machines in the same order M 1,M 2,...,M m. For the open shop, the job processing routes are not given but must be chosen, different jobs being allowed to follow different routes. A flow shop or an open shop schedule is said to satisfy the no-wait in process restriction if, for any job and any pair of consecutive operations in the processing route, the processing stage of the latter operation must start exactly when the processing stage of the former operation is completed. In what follows we also consider the no-wait versions of the flow shop and the open shop problems with a single server. Throughout this paper we consider the case of sequence-independent setup times, assuming that for any machine M i the setup times of the jobs assigned to that machine do not depend on the sequence in which the jobs are performed on M i. Furthermore, for the multistage models, throughout the paper we assume that the setups are anticipatory. This implies that, for a pair of consecutive operations of the same job the setup for the second operation can be done simultaneously with the processing stage of the first. This type of setups is applied when the presence of the job is not needed in order to prepare the machine for processing that job (e.g., changing Figure 1. A schedule for three dedicated machines.

4 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 307 a program for a numerically controlled machine-tool). Setups of this type differ from nonanticipatory setups, where for any job no setup can be done on the downstream machine before the job is fully completed on the previous machine. Our interpretation of anticipatory setups is also different from the interpretation studied in [15]. An instance of the problem may contain jobs with very small processing and/or setup time. Such short operations have insignificant impact on the value of the objective function. These small times can be considered as essentially zero, and we write p ij =0(or s ij =0) to denote them. In this case the corresponding operation is completed at the same time it starts. Still, we cannot simply drop the small operations, since they have influence on the structure of the schedule producing possible machine or server interference. For a schedule S, the value of the makespan is denoted by C max (S). In the remaining part of the paper we often deal with the two machine cases of various scheduling problems, and it is convenient to adopt the following special notation in these cases. Let A, B denote the machines, a j,b j the processing times of job J j on machines A and B, respectively, and α j,β j the setup times of job J j on machines A and B, respectively. For the two parallel dedicated machine problem we suppose that set N of jobs is partitioned into two subsets: N = N A N B, and the jobs from the first subset are to be processed on machine A, while those from the second subset are processed on machine B. Extending standard notation for scheduling problems [14], and also following Hall et al. [11] where similar models are studied, we use the following notation to refer to the problems under consideration: PD,S C max parallel dedicated (PD) machine scheduling problem with a single server (S); F, S C max flow shop scheduling problem with a single server; O, S C max open shop scheduling problem with a single server; F, S no-wait C max flow shop no-wait scheduling problem with a single server; O, S no-wait C max open shop no-wait scheduling problem with a single server. Notice that we use the notation above when the number of the processing machines m is variable. If m is fixed, this is indicated explicitly; for example, we write PD2,S C max to refer to the scheduling problem with two parallel dedicated machines and a single server. Following standard notation, we use F C max and O C max to denote the classical flow shop and the open shop scheduling problems, respectively, with no additional constraints. If the no-wait restriction is imposed, we write F no-wait C max and O no-wait C max. 3. RELATED SCHEDULING MODELS Before proceeding with the analysis of our problem, we compare our model with other relevant models in the scheduling theory literature. First, the recent paper [2] by Blazewicz, Dell Olmo, and Drozdowski considers a more general situation called client server scheduling model. In their model there are m parallel machines (clients). The client reads data from the server, processes it, and writes the result back to the server. The tasks can be distributed in advance, in which case the machines are dedicated; an alternative version assumes that the decision-maker has also to assign the tasks to machines. The paper presents a series of interesting applications of the client server model, some of which are relevant for our model. A number of complexity and approximation results are presented in [2]. Some of them are quoted in the corresponding sections of our paper. We now pass to the PD2,S C max problem. Hall et al. [11] study a similar model in which the processing machines are not dedicated but parallel identical. They give the detailed complexity classification of scheduling problems with parallel identical machines and a single server under

5 308 Naval Research Logistics, Vol. 47 (2000) various assumptions regarding the setup times and the processing times for most common objective functions. In the case of the makespan to be minimized, it is shown that the problem with two parallel machines and a single server, denoted by P 2,S C max,isnp-hard in the strong sense even if all setup times are equal. Also, even if all setup times are unit and all processing times are integer, the P 2,S C max problem is NP-hard in the ordinary sense, and it is an open question whether the problem is NP-hard in the strong sense. For the m-machine case of the problem, Hall et al. [11] present several heuristic algorithms, the best of which guarantees a worst-case performance ratio of 2 1/m. Consider the flow and open shop problems with a single server. Notice that the server in the model under consideration can be viewed as an additional renewable resource such that the resource is required at any time of the setup phase of any operation. This resembles various scheduling models with resource constraints (see [3] for a review). The point of difference, however, is that in the models discussed in [3] the resource is consumed in the processing stage, not in the setup stage, and in addition any setup times are normally incorporated into the processing times. We use res111 in the middle field of the standard scheduling notation to denote the special case in which some of the operations require one unit of a single resource and one unit of the resource is available at a time. Another set of scheduling problems relevant to the models studied in this paper comprises the scheduling problems with setup times separated (see [1] for a review). As in our model, an operation is assumed to consist of two phases: the setup and the processing; however, no server is needed to run the setup. We use setup to denote a situation in which the setup times are separated from the processing times. The two-machine flow shop problem with a single server is considered in [4]. For this model the server performs not only the setup phase, but also the dismounting phase which follows the actual processing. The complexity and approximation results are given for a specific pattern of the server movements. Table 2 presents the known complexity results on the scheduling problems with a single server and some relevant problems. In Table 2, we write NP if the corresponding problem is NPhard in the strong sense; we write NP? if the problem is NP-hard in the ordinary sense and is not known to be NP-hard in the strong sense; otherwise, we present the running time of an algorithm that solves the problem. If the complexity status of a problem is not known, we write Open. The references are provided to the published papers. 4. COMPLEXITY RESULTS FOR PARALLEL DEDICATED MACHINES We start our analysis by demonstrating that even under several simplifying assumptions the problems with a single server are difficult to solve. In this section, we investigate the computational complexity of two special cases of the parallel dedicated machine problems with just two machines, PD2,S C max. We prove that each of them is NP-hard in the strong sense. We write PD2,S a j = b k = a C max to denote the PD2,S C max problem if all processing times are equal, i.e., a j = a and b k = a for all j N A and k N B. Similarly, we write PD2,S α j = β k = α C max to denote the PD2,S C max problem if all setup times are equal. The following problem will be used for the reduction. 3-Partition: Given 3t positive integers e 1,e 2,...,e 3t, where i T e i = te with T = {1, 2,...,3t}, for some E and E/4 <e i <E/2for i =1, 2,...,3t, does there exist a partition of the index set T into t disjoint subsets T j such that i T j e i = E for each j =1, 2,...,t? It is well known that 3-Partition is NP-hard in the strong sense (see, e.g., [5]).

6 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 309 Table 2. Complexity of related shop scheduling problems The Model Complexity Reference P 2,S α j = β k = α C max NP [11] F 2 C max O(n log n) [12] F 3 C max NP [6] F 2 res111 C max NP [3] F 2 setup C max O(n log n) [20] F 2 no-wait C max O(n log n) [7, 8] F 3 no-wait C max NP [17] F 2 no-wait, res111 C max Open [3] F 2 no-wait, setup C max O(n log n) [10] O2 C max O(n) [9] O3 C max NP? [9] O2 res111 C max O(n) [16, 13] O2 setup C max O(n) [19] O2 no-wait C max NP [18] O2 no-wait, res111 C max NP [18] O2 no-wait, setup C max NP [18] THEOREM 1: The PD2, S a j = b k = a C max problem is NP-hard in the strong sense. PROOF: Given an arbitrary instance of 3-Partition, define the following instance of the PD2,S C max problem with n =6t +1jobs. The set of jobs is divided into three groups: U- jobs, denoted by U i,i =1, 2,...,3t; V -jobs, denoted by V k,k =1, 2,...,2t +2; and W -jobs, denoted by W l,l =1, 2,...,t 1. All U-jobs are assigned to be processed on machine A, while the V -jobs and the W -jobs are to be processed on machine B. The setup and the processing times are defined as follows: α Ui = e i, a Ui = E, i =1, 2,...,3t, β Vk = 0, b Vk = E, k =1, 2,...,2t +2, β Wl = E, b Wl = E, l =1, 2,...,t 1. Observe that all processing times are equal to E. To prove the theorem we show that in this constructed instance of the PD2,S a j = b k = a C max problem a schedule S 0 satisfying C max (S 0 ) y =4tE exists if and only if 3-Partition has a solution. Suppose that 3-Partition has a solution, and T j, j = 1, 2,...,t, are the required subsets of set T. Notice that each set T j contains precisely three elements, since E/4 <e i <E/2 and i T j e i = E for all j = 1, 2,...,t. Let π denote a permutation of the elements of set T for which T j = {π(3j 2), π(3j 1), π(3j)}, for j = 1, 2,...,t. The desired schedule S 0 exists and can be described as follows. No machine has intermediate idle time. Machine A processes the U-jobs in order of the permutation π, i.e., in the sequence (U π(1),u π(2),u π(3),...,u π(3t 2),U π(3t 1),U π(3t) ),

7 310 Naval Research Logistics, Vol. 47 (2000) Figure 2. Schedule S 0. while machine B processes the jobs in the sequence (V 1,V 2,V 3,W 1,V 4,V 5,W 2,...,W t 2,V 2t 2,V 2t 1,W t 1,V 2t,V 2t+1,V 2t+2 ). It is easy to check that the suggested schedule is feasible, i.e., produces no server interference, and that C max (S 0 )=y. See Figure 2. Suppose now that a desired schedule S 0 exists. Since the total workload on each machine is equal to y, it follows that C max (S 0 )=y and neither machine has any idle time. Without loss of generality, we may assume that machine B processes the V -jobs and the W -jobs in increasing order of their numbering. Let I β l =[τ l,τ l + E] denote the time interval in which machine B performs the setup of job W l,l =1, 2,...,t 1. Forl, 2 l t 1, introduce the interval Il b =[τ l 1 + E,τ l ].We also introduce the time interval I1 b =[τ 0,τ 1 ], where τ 0 =0for convenience, and the interval It b =[τ t 1 + E,y]. Notice that in each interval Il b, 2 l t, machine B at least performs the processing of job W l 1. The length of the interval I1 b is also strictly positive. This follows from the observation that job W 1 cannot be the first on machine B; otherwise, machine A would be idle in the time interval [0,E]. Since all nonzero setup times and all processing times on machine B are equal to E, we conclude that the length of each interval Il b, 1 l t, is a multiple of E. Since machine A has no idle time, it follows that A must be busy in each interval I β l performing the processing of exactly one U-job. Let P l denote the set of indices of the U-jobs which are set up in interval Il b, for l =1, 2,...,t. For each l, l =1, 2,...,t 1, the U-job that is processed in interval I β l must be set up in interval Il b; therefore, set P l is not empty and the length of interval Il b is equal to i P l (α Ui + a Ui ) E = i P l e i + P l E E. In interval It b machine A processes at least one U-job which must be set up in that interval; therefore, set P t is not empty as well and the length of interval It b is equal to i P t (α Ui + a Ui )= i P t e i + P t E. For all these values to be multiples of E, the inequalities P l 3must hold for all l = 1, 2,...,n, since E/2 <e i <E/4,i T. There are exactly t intervals Il b, and in these intervals exactly 3t jobs have to be set up. Therefore, we must have that P j =3and i P j e i = E for all j =1, 2,...,t. Thus, the sets T j = P j give a solution to 3-Partition. We now consider the case of the PD2,S C max problem where the processing times are arbitrary, while all setup times are identical. THEOREM 2: The PD2,S α j = β k = α C max problem is NP-hard in the strong sense. PROOF: Given an arbitrary instance of 3-Partition, define the following instance of the PD2,S C max problem with two machines A and B and n =5t 1jobs. The set of jobs is divided into three groups: U-jobs denoted by U i,i =1, 2,...,3t; V -jobs, denoted by V j,j = 1, 2,...,t 1; and W -jobs denoted by W j,j =1, 2,...,t. All U-jobs and V -jobs are assigned

8 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 311 to be processed on machine A, while the W -jobs are to be processed on machine B. The setup and processing times are defined as follows: α Ui = E, a Ui = e i, i =1, 2,...,3t, α Vj = E, a Vj = E, j =1, 2,...,t 1 β Wk = E, b Wk =5E, k =1, 2,...,t 1, β Wt = E, b Wt =4E. Notice that all setup times are equal to E. To prove the theorem, we show that in the constructed instance of the problem a schedule S 0 such that C max (S 0 ) y =6tE E exists if and only if 3-Partition has a solution. Suppose that 3-Partition has a solution, and T j,j =1, 2,...,t, are the required subsets of set T. Let π denote a permutation of the set T for which T j = {π(3j 2),π(3j 1),π(3j)}, for j =1, 2,...,t. The desired schedule S 0 exists and can be described as follows. Machine A processes the jobs in the sequence (U π(1),u π(2),u π(3),v 1,U π(4),u π(5),u π(6),v 2,...,V t 1,U π(3t 2),U π(3t 1),U π(3t) ), while machine B processes the jobs in the sequence (W 1,...,W t ). In the interval [0,E] machine A is idle, while job W 1 is set up on machine B. Subsequent jobs W k are set up on machine B while job V k 1 is being processed on machine A, k =2, 3,...,t. While job W k is being processed on machine B, machine A performs the setup and the processing of three jobs U i for i T k, and the setup of job V k 1. Thus, the suggested schedule is feasible, i.e., produces no server interference, and C max (S 0 )=6tE E = y. Suppose now that the desired schedule S 0 exists. Since the total workload on machine B is equal to y, it follows that C max (S 0 )=yand, moreover, that machine B is never idle. Thus, in the time interval [0,E] machine B performs the setup of some W -job. Since any job assigned to machine A requires nonzero setup time, no activity can be done on A in the interval [0,E], so that this machine is idle in [0,E]. As the total workload on machine A equals y E, machine A is not idle in the time interval [E,y]. Since the jobs W k, 1 k t 1, are identical, we assume that they are processed on machine B in increasing order of their numbering. To describe how machine B operates in schedule S 0, we need to specify the position of the unique job W t. Assume that W t occupies the rth position, 1 r t, so that machine B processes the W -jobs in the sequence σ B = (W 1,...,W r 1,W t,w r,...,w t 1 ). Let I β k and Ib k denote the time intervals during which machine B performs the setup and the processing, respectively, of the W -job that occupies the kth position in sequence σ B, 1 k t. During each of the I β k intervals machine A may be doing only the processing, not the setup, of some job. Since only V -jobs have the processing time equal to E and machine A does not have idle time in the interval [E,y], we conclude that in each of t 1 time intervals I β k for k =2, 3,...,t machine A performs the processing of exactly one V -job. Moreover, since the V -jobs are identical, we may assume that in the interval I β k, 2 k t, machine A performs the processing of job V k 1. Thus, exactly E time units of each interval Ik b,k t 1, must be taken by the setup of job V k on machine A. The remaining intervals provide room for setting up and processing the U-jobs on A. Suppose that job W t is placed at the rth position in sequence σ B, where r<t. Then in the interval Ir b there are 3E time units left for setting up and processing some of the U-jobs. Since

9 312 Naval Research Logistics, Vol. 47 (2000) the setup time of any U-job equals E, it follows that exactly two U-jobs, say, U i1 and U i2, can be assigned to the interval Ir, b and that their combined processing time must be e i1 + e i2 = E, which is impossible since e i <E/2for all i, i =1, 2,...,3t. Therefore, job W t occupies the last position in sequence σ B, and no V -job is processed on A in this interval. Thus, in each interval Ik b, 1 k t 1, there are 4E time units left for setting up and processing the U-jobs. Also, the interval It b associated with job W t provides 4E time units. Therefore, exactly three U-jobs with total processing time equal to E must be assigned to be processed in each of the intervals Ij b,j =1, 2,...,t. Denoting by T j the index set of the U-jobs processed in interval Ij b, we obtain a solution to 3-Partition. 5. APPROXIMATION ALGORITHM FOR PARALLEL DEDICATED MACHINES The NP-hardness of our parallel machine problem with a single server motivates the search for polynomial-time approximation algorithms. In this section we show that a simple greedy algorithm applied to the PD,S C max problem creates a schedule with a makespan that is at most twice as large as the optimal value. We also prove that the bound of 2 is tight, i.e., for any m there exists an instance of the problem for which this bound is attained. Let S denote an optimal schedule for the PD,S C max problem. We have that C max (S ) m i=1 j N i s ij, (1) since the server can do only one setup at a time. Also, for any machine M i, 1 i m,wehave C max (S ) p ij + s ij. (2) j N i j N i For the PD,S C max problem, we consider a simple greedy algorithm that scans the jobs in the arbitrary order. In the resulting schedule S 0 a machine is idle only if neither the setup nor the processing of a job may be started on it. Algorithm 1 1. For each machine M i make an arbitrary sequence (a list) L i of jobs of set N i,i=1, 2,...,m. 2. At any time when both a machine M i and the server become available, the next job from the list L i is assigned to be processed on M i, 1 i m. The ties for machines are broken arbitrarily. The assigned job is removed from the list. For the assigned job the processing immediately follows the setup. Stop when all lists are empty. Call the resulting schedule S 0. It is evident that Algorithm 1 takes O(mn) time. THEOREM 3: For the P Dm, S C max problem, let S 0 be a schedule created by Algorithm 1. Then and this bound is tight for any m. C max (S 0 ) C max (S 2, (3) )

10 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 313 PROOF: Consider schedule S 0, and suppose that a machine M q, 1 q m, terminates this schedule. Let I q (S 0 ) denote the idle time on machine M q. Then C max (S 0 )= p qj + s qj + I q (S 0 ) j N q j N q and m I q (S 0 ) s ij s qj, i=1 j N i j N q since whenever machine M q is idle, the server is busy doing the setup of a job on some other machine. Thus, due to (1) and (2) we have C max (S 0 ) j N q p qj + m i=1 j N i s ij 2C max (S ), which corresponds to (3). To see that this bound is tight, consider the following instance of the P Dm, S C max problem. There are n = m +2jobs with the setup and processing times defined as follows. For any value of m, s 11 = ε, p 11 = ε, s 12 =1, p 12 = ε, s 23 = ε, p 23 = ε, s 24 = ε, p 24 =1, where ε<1 is an arbitrarily small number. Also, if m 3, define s i,i+2 = δ, p i,i+2 =1, i =3,...,m, where δ = ε/(m 2). The jobs are assigned to the machines as follows: N 1 = {J 1,J 2 },N 2 = {J 3,J 4 }, and, if m 3,N i = {J i+2 }, for i =3,...,m. Let m t 0 = s ij =1+4ε. i=1 j N i The makespan for an optimal schedule S is no smaller than the sum of all setup times plus the smallest processing time, i.e., C max (S ) t 0 + ε. A schedule that attains this lower bound can be found by allocating the jobs to the server in the order 5, 6,...,m,4, 2, 3, 1. None of the machines has intermediate idle time, the server is busy between the first and last setups, machine M 1 terminates the schedule, and C max (S )=t 0 + p 11 = t 0 + ε =1+5ε. See Figure 3(a). On the other hand, Algorithm 1 creates a schedule S 0 in which the jobs are allocated to the server in the order 5, 6,...,m,1, 3, 2, 4. The server is permanently busy between the first and last job setups, machine M 2 is the last to finish and the only one with intermediate idle time, and C max (S 0 )=t 0 + p 24 = t 0 +1=2+4ε. See Figure 3(b). Thus, C max (S 0 )/C max (S )=(2+4ε)/(1+5ε) 2 as ε 0. This completes the proof of the theorem.

11 314 Naval Research Logistics, Vol. 47 (2000) Figure 3. Tightness of Algorithm 1: (a) schedule S ; (b) schedule S 0. Algorithm 1 can be extended to be applied to the client-server scheduling problem with dedicated machines; as shown in [2] the performance ratio of 2 is maintained for that more general problem. Notice that Algorithm 1 takes jobs one at a time as they appear in the lists. This property allows the algorithm to be run in the on-line mode, which can be important for computing applications. Because the algorithm deals with arbitrary lists, it is clear that the performance bound of 2 is preserved for the on-line version of the algorithm. 6. HEURISTIC FOR TWO PARALLEL DEDICATED MACHINES In this section, we develop an approximation algorithm for the PD2,S C max problem with a better worst-case bound than the one presented above for an arbitrary number of machines. To be more precise, the algorithm runs in O(n log n) time and generates a schedule with the makespan that is at most 3/2 times that of an optimal schedule. This bound of 3/2 is proved to be tight. Recall that in the two machine case the set N of jobs is partitioned into two subsets N A and N B to be processed on machine A and machine B, respectively. Assume that there are n = p + q jobs and that N A = {J 1,J 2,...,J p } and N B = {J p+1,j p+2,...,j p+q }. It is convenient to use the following notation, α(n A )= p α j,a(n A )= p a j,β(n B )= q β p+j, and b(n B )= q b p+j.form =2the bounds (1) and (2) can be written as and C max (S ) α(n A )+β(n B ) (4) C max (S ) max{α(n A )+a(n A ),β(n B )+b(n B )}. (5) For a schedule S, let I A (S) denote the total idle time on machine A in S. The value I B (S) is defined analogously. We have that C max (S) = max{β(n B )+b(n B )+I B (S),α(N A )+a(n A )+I A (S)}. (6) Now we will establish a new lower bound on the optimal value of the makespan by estimating the total idle time on machine B. Unless stated otherwise, in the remainder of this section, it is assumed that the jobs of set N A are numbered in such a way that α 1 α 2 α p, (7)

12 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 315 and the jobs of set N B are numbered in such a way that b p+1 b p+2 b p+q. (8) LEMMA 1: Suppose that for the PD2,S C max problem the numbering of the jobs satisfies (7) and (8). For an optimal schedule S, the following bound, C max (S ) β(n B )+b(n B )+γ, holds, where k γ = max 0, max (α j b p+j ) 1 k p (9) and b p+q+1 = = b 2p =0if p>q. PROOF: Let IB k (S ) denote the total length of all idle intervals on machine B during which machine A performs the setup of one of the jobs J 1,J 2,...,J k, 1 k p. While machine A performs the setup of some job of set N A, machine B can only do the processing of at most one job of set N B. Since the jobs of set N B are numbered in nonincreasing order of their processing times, we have that for any k, 1 k p, the following inequality: holds. This implies that k IB(S k ) max 0, α j k b p+j I B (S ) = max{i k B(S ) k =1, 2,...,p} γ, which, in turn, being combined with the bound (6) with S = S, proves the lemma. For the PD2,S C max problem, we introduce a heuristic algorithm that either accepts a schedule found by Algorithm 1, or constructs a schedule by running a greedy algorithm that uses a specific list of jobs for one of the machines. Algorithm 2 1. Find the values α(n A ),a(n A ),β(n B ), and b(n B ). 2. If or α(n A ) a(n A ),β(n B ) b(n B ) (10) α(n A ) a(n A ),β(n B ) b(n B ), then run Algorithm 1 to find schedule S 0 for the PD2,S C max problem and stop. Otherwise, go to Step 3.

13 316 Naval Research Logistics, Vol. 47 (2000) 3. Suppose that otherwise rename the machines. α(n A ) >a(n A ),β(n B ) b(n B ); (11) a) Let L A be an arbitrary list of the jobs J 1,J 2,...,J p. If necessary, renumber the other jobs in such a way that (8) holds and make the list L B = (J p+1,j p+2,...,j p+q ). b) Start a schedule by assigning the setup of job J p+1 to start on machine B at time zero. Remove J p+1 from list L B. c) At any time when both a machine Q {A, B} and the server become available, the next job from the list L Q is assigned to be processed on Q. The assigned job is removed from the list. For the assigned job the processing immediately follows the setup. Repeat until both lists are empty. Call the resulting schedule S 0 and stop. It is easy to verify that the running time of Algorithm 2 is O(n log n). We demonstrate that a worst-case performance ratio of Algorithm 2 cannot be better than 3/2. Consider the following instance of the PD2,S C max problem. There are four jobs assigned to the machines as follows: N A = {J 1,J 2 } and N B = {J 3,J 4 }. The setup and processing times are defined below: α 1 = 1, a 1 = ε, α 2 =1, a 2 = ε, β 3 = ε, b 3 =1+ε, β 4 = ε, b 4 =1, where ε<1is an arbitrarily small positive number. The makespan for an optimal schedule S is equal to 2+3ε, which is the total workload on machine B. This schedule allocates the jobs to the server in the order 4, 1, 3, 2. The conditions of Step 3 of Algorithm 2 hold, so that schedule S 0 may be created in which the jobs are allocated to the server in the order 3, 1, 2, 4 and hence C max (S 0 ) = 3+3ε. Thus, C max (S 0 )/C max (S ) 3/2 as ε 0. We now show that 3/2 is an upper bound on the worst-case performance ratio of Algorithm 2. THEOREM 4: For schedule S 0 created by Algorithm 2 for the PD2,S C max problem the following bound, holds, and this bound is tight. C max (S 0 ) C max (S ) 3 2, (12) PROOF: The tightness of the bound (12) follows from the example above. To prove inequality (12), we split our consideration into several cases. CASE 1: Suppose that the conditions of Step 2 hold. Without loss of generality, assume that the inequalities (10) are valid; in the other case, the proof is similar. Thus, using bound (5), we have a(n A ) 1 2 C max(s ). (13)

14 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 317 Consider schedule S 0 found by Algorithm 1. If this schedule is terminated on machine A, then whenever machine A is idle the server is busy doing setup of some job on the other machine. Thus, I A (S 0 ) β(n B ). Moreover, it follows from (6) that C max (S 0 )=α(n A )+a(n A )+I A (S 0 ). Combining these two relations with (4) gives (12). Similarly, if schedule S 0 is terminated on machine B, the same result holds since machines A and B are interchangeable in the statement of the problem, in Algorithm 1 and in the relations (4), (5), (10), and (12). CASE 2: Suppose that the conditions of Step 2 do not hold. Then (11) of Step 3 holds, possibly after the machines are renamed. Applying (5), we derive that (13) holds. If schedule S 0 is terminated on machine A, then the above argument may be applied to give (12). Thus, in the rest of the proof, we assume that schedule S 0 is terminated on machine B. For schedule S 0, let denote the total length of all time intervals during which both machines are simultaneously busy. We derive that C max (S 0 )=α(n A )+a(n A )+β(n B )+b(n B ). CASE 2.1: Suppose that where γ is defined by (9). Rewrite (14) as α(n A )+a(n A ) 1 2 (β(n B)+b(N B )) 3 2γ, (14) α(n A )+a(n A )+β(n B )+b(n B ) 3 2 (β(n B)+b(N B )+γ). Then, using Lemma 1, we obtain which leads to (12). α(n A )+a(n A )+β(n B )+b(n B ) 3 2 C max(s ), CASE 2.2: In the remainder of this proof we assume that (14) does not hold. Let the order of the jobs in the list L A be given by some permutation π, so that L A = (J π(1),j π(2),...,j π(p) ). Consider the last idle interval on machine B in schedule S 0 and assume that this idle interval is caused by the setup of a job J π(u), 1 u p. Let v denote the number of jobs completed on machine B before that idle interval. The total idle time on A before machine B starts the processing of job J p+v+1 does not exceed β(n B ). Therefore, we have that C max (S 0 ) u (α π(j) + a π(j) )+β(n B )+ q j=v+1 b p+j. Recall that the jobs on A are assumed to be numbered in such a way that (7) holds, although Algorithm 2 does not necessarily scans the jobs in that order. This implies that u u α π(j) α j.

15 318 Naval Research Logistics, Vol. 47 (2000) Using this observation, we obtain C max (S 0 ) u α j + a(n A )+β(n B )+ q j=v+1 We consider the cases when u v and when u v +1separately. CASE 2.2.1: u v. It follows that q q u b p+j b p+j = b(n B ) b p+j, j=v+1 and hence from (9) and (15) we derive j=u+1 C max (S 0 ) a(n A )+β(n B )+b(n B )+γ. Due to (13) and Lemma 1, the last relation yields (12). CASE 2.2.2: u v +1. Recall that machine B is assumed to terminate schedule S 0, so that (6) yields C max (S 0 )=β(n B )+b(n B )+I B (S 0 ). b p+j. (15) Observe that the number of idle intervals on machine B cannot exceed the number of jobs v completed on B before the last idle interval on that machine. Therefore, these idle intervals are caused by no more than v setups performed on machine A. Since the jobs of set N A are numbered in nonincreasing order of their setup times, we derive the inequality I B (S 0 ) v α j. If v α j C max (S )/2, then the required bound (12) follows immediately from (5). Consider the remaining case when v α j >C max (S )/2 and (14) does not hold, so that <α(n A )+a(n A ) 1 2 (β(n B)+b(N B )) 3 2 γ. Since in schedule S 0 machine A is not idle while machine B performs the processing of the jobs J p+1,...,j p+v, we derive that v b p+j. It follows from (9) that γ v (α j b p+j ).

16 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 319 Combining the previous three inequalities, we obtain v b p+j <α(n A )+a(n A ) 1 2 (β(n B)+b(N B )) 3 v 2 (α j b p+j ). Rearranging the terms and scaling up by a factor of 2 results in the inequality v q p α j + b p+j 2 α j +2a(N A ) β(n B ). j=v+1 j=v+1 Rewriting (15) and then substituting the latter inequality yields C max (S 0 ) v α j + q + u α j + a(n A )+β(n B ) 2 3 p j=v+1 j=v+1 b p+j α j +3a(N A )+ p α j +3a(N A ) 3 j=v+1 u j=v+1 v α j. Applying bound (5) and the condition v α j C max (S )/2 gives the required inequality (12). Thus, we have proved that schedule S 0 found by Algorithm 2 is no more than 3/2 times worse than an optimal schedule. This completes the proof of the theorem. α j 7. POLYNOMIALLY SOLVABLE CASES We now present several polynomially solvable cases of the PD2,S C max problem. In this section, for finding optimal schedules, we often use Algorithm 1 modified to ensure that the server starts with machine B. Since no confusion arises, we still refer to this modified algorithm as Algorithm 1. Throughout this section we assume that N A = {J 1,J 2,...,J p }, N B = {J p+1, J p+2,..., J p+q }, and p q; otherwise, the machines may be renamed. Unless stated otherwise, in all cases considered in this section the following conditions: a j β k + b k and b k α j + a j (16) simultaneously hold for all j {1, 2,...,p} and k (p+1,...,n}. Let S 1 be the schedule found by Algorithm 1. It can be verified that (16) guarantees that in schedule S 1 the server alternates between the machines as long as there are jobs still to be scheduled on machine A. Therefore, schedule S 1 may be described by the permutation (J p+1,j 1,J p+2,j 2,...,J 2p,J p,j 2p+1,J 2p+2,...,J n ), (17) according to which the server sets up the jobs, with each machine starting the processing of a job immediately after its setup is completed. Recall that in Section 3 we proved that the problem is NP-hard in the strong sense even if all processing times are equal, i.e., a j = b k = a for all j {1, 2,...,p} and k {p +1,...,n}, or else if all setup times are equal, i.e., α j = β k = α. We now examine the case when both conditions hold.

17 320 Naval Research Logistics, Vol. 47 (2000) PROPOSITION 1: The PD2,S α j = β k = α, a j = b k = a C max problem in which all processing times are equal and all setup times are equal is polynomially solvable. PROOF: We show that the running time required for finding an optimal schedule S is polynomial with respect to the input length of the problem. The conditions (16) obviously hold. Schedule S 1 represented by the permutation (17) found by Algorithm 1 can be proved to be optimal. Notice, however, that finding this representation takes O(n) time, and this time cannot be considered as polynomial. Indeed, any instance of the problem may be given by four numbers: p, q, α, and a. Thus, the length of the input does not exceed log p + log q + log α + log a. Notice that n = p + q. On the other hand, the same schedule S 1 can be represented by a function ϕ, where ϕ(j) is equal to the starting time of the setup of job J j,j =1, 2,...,n. We have two cases to consider, when α a and when α>a. (a) α a. Simple calculations result in the formula { jα +(j 1)a, if j p, ϕ(j) = (j p 1)α +(j p 1)a, if j>p. It follows that { q(α + a), if q>p, C max (S 1 )= q(α + a)+α, if q = p, which implies that S 1 is an optimal schedule. To see this, notice that the makespan of S 1 is equal to the total workload on machine B if q>p. Otherwise, if q = p, the value q(α + a)+α cannot be reduced because the workload of each machine equals q(α + a) and one of them cannot start before time α. (b) α>a. In this case we obtain ϕ(j) = (2j 1)α, if j p, 2(j p 1)α, if p<j 2p +1, (j 1)α +(j 2p 1)a, if j>2p +1. It follows that C max (S 1 )= { nα +(q p)a, if q>p, nα + a, if q = p. If q>p, then the makespan of S 1 meets the lower bound established in Lemma 1, and so S 1 is an optimal schedule. Observe that the sum of all setup times plus the smallest processing time is an obvious lower bound on the makespan of any feasible schedule. Therefore, if q = p, the value nα + a cannot be reduced and again S 1 is an optimal schedule. Every value of function ϕ can be found in constant time, which implies that this representation of an optimal schedule is polynomial. PROPOSITION 2: The PD2,S C max problem is solvable in O(n log n), provided that the following conditions, hold. min{α j j {1, 2,...,p}} max{b l l {p +1,p+2,...,n}}, min{β j j {p +1,p+2,...,n}} max{a j j {1, 2,...,p}},

18 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 321 PROOF: If necessary, renumber the jobs so that a 1 a 2 a p and b p+1 b p+2 b n, and assume that Algorithm 1 scans the jobs according to these sequences. Observe that the problem satisfies the conditions (16), so that schedule S 1 found by Algorithm 1 may be described by the permutation (17). If q>p, then in schedule S 1 the server is not idle while there are jobs on both machines A and B yet to be completed, since the processing of a job on some machine takes less time than the setup of another job being done in parallel on the other machine. We deduce that C max (S 1 )= p α j + n l=p+1 β l + n k=2p+1 b k. (18) Notice that this value cannot be reduced because of the numbering of the jobs assigned to machine B. Moreover, the right-hand side of Eq. (18) is equal to β(n B )+b(n B )+ p (α j b p+j ) which by Lemma 1 is a lower bound on the optimal makespan. Therefore, the schedule S 1 is optimal. Observe that the assumption that a 1 a 2 a p is used here only for consistency reasons. Algorithm 1 may scan the jobs assigned to machine A in any order and still will find a schedule with the makespan satisfying (18). If q = p, then running Algorithm 1 gives C max (S 1 )= p α l + l=1 n l=p+1 β l + a p, which is the best schedule among those terminated by machine A. Again notice that in fact a special order of jobs on machine B, and, moreover, the full ordering a 1 a 2 a p are not required; it is sufficient to ensure that a p is the smallest processing time on machine A. Reverse the roles of machine A and machine B and run Algorithm 1 again. Let S 1 denote the schedule found by this second run of Algorithm 1. This time the server starts on machine A. Since p = q, schedule S 1 terminates on machine B, so that C max (S 1)= p α l + l=1 n l=p+1 β l + b 2p. Notice that for the second run of Algorithm 1 we only need to ensure that b 2p is the smallest processing time on machine B; the other assumptions regarding the orders of jobs are immaterial. The better of the two schedules S 1 and S 1 yields schedule S with C max (S )= p α l + l=1 n l=p+1 β l + min{a j,b p+j j =1, 2,...,p}. This schedule is optimal, since the makespan equals the total setup time plus the smallest processing time. The running time required for finding an optimal schedule does not exceed O(n log n). If q>p, then the above construction, optimality argument and the running time consideration may be applied to the following more general case. Notice that in this case we do not need inequality (16).

19 322 Naval Research Logistics, Vol. 47 (2000) PROPOSITION 3: The PD2,S C max problem with q>pis solvable in O(n log n) time, provided that the jobs can be numbered in such a way that and α 1 b p+1,α 2 b p+2,...,α p b 2p, α 1 α 2 α p, b p+1 b p+2 b n, min{β k k = p +1,...,n} max{a j j =1,...,p}. Moreover, the following special case within Proposition 2 is worth stating separately as a less complex algorithm may be used to find an optimal solution. PROPOSITION 4: The PD2,S a j = b k =1,α j 1,β k 1 C max problem with unit processing times is solvable in O(n) time. In this case we may apply the algorithm described in the proof of Proposition 2 but omitting the ordering of the processing times. This reduces the required running time to O(n). Observe that this is in contrast to the problem PD2,S a j = b k = a C max, which has been shown to be NP-hard in the strong sense in Theorem 1. Notice also that in the case of two undedicated parallel machines the problem with unit processing times is NP-hard in the ordinary sense as proved by Hall et al. in [11]. 8. SHOP SCHEDULING PROBLEMS In this section we consider some shop scheduling problems with a single server. Since all relevant classical scheduling problems with three or more machines are NP-hard (see Table 2) we expect to derive new complexity results for two machine shop problems. We demonstrate that most of these problems are NP-hard, except the two machine no-wait flow shop problem which is shown to be polynomially solvable. Observe that the PD2,S C max problem can be seen as either the F 2,S C max problem or the O2,S C max problem, provided that only one operation of each job has nonzero setup and/or processing times. Thus, Theorem 1 implies the following statement. COROLLARY 1: Both the F 2,S C max problem and the O2,S C max problem are NP-hard in the strong sense. We now concentrate on the no-wait problems. First, notice that the O2,S no-wait C max problem is a generalization of the O2 no-wait C max problem with no server. Since the latter problem is NP-hard in the strong sense (see [18]), the following statement holds. THEOREM 5: The O2,S no-wait C max problem is NP-hard in the strong sense. The remainder of this section is devoted to the F 2,S no-wait C max problem. Recall that the complexity of the flow shop problems with no-wait in process (without a server) essentially depends on the interpretation of the zero processing times. If zero processing time of an operation is understood so that the corresponding operation is missing, then the F 2 no-wait C max problem is NP-hard in the strong sense [18]. Therefore, under this interpretation of zero processing (and setup) times, the F 2,S no-wait C max problem has the same complexity status. On the other

20 Glass, Shafransky and Strusevich: Scheduling Parallel Dedicated Machines 323 hand, if zero processing times are treated as arbitrarily small positive values, then for the F 2 nowait C max problem in any schedule both machines process the jobs in the same sequence and the problem is solvable in O(n log n) time by the Gilmore Gomory algorithm [8]. We show that, under the latter interpretation of zero times, this algorithm can be extended for solving the F 2,S no-wait C max problem. We start with the algorithm that finds a schedule S for the F 2,S no-wait C max problem associated with a given permutation π =(π(1),π(2),...,π(n)) of jobs. In other words, given a permutation π, we show how to determine the start or completion time of each setup and processing operation so that: (i) both machines process the jobs according to the permutation π; (ii) no server conflict occurs; (iii) the processing phase of each job on machine B starts at the time the processing of that job on machine A is completed; and (iv) the makespan of the resulting schedule cannot be reduced. For an arbitrary schedule S, let Cj a(s) and Cb j (S) denote the completion time of the processing of job J j on machines A and B, respectively. Similarly, Cj α(s) and Cβ j (S) denote the completion times of the setup of job J j on machines A and B, respectively. The starting times for these processing and setup operations are denoted by Rj a(s),rb j (S),Rα j (S), and Rβ j (S), correspondingly. When it is clear which schedule is being considered, we may write Cj a, etc., omitting the reference to S. Clearly, the start and completion times of an operation differ by the duration of that operation, e.g., Cj a = Ra j + a j. Notice that the no-wait condition implies that Cj a = Rb j for every job J j in any feasible schedule. We denote τ j = C a j = R b j and call this time the changeover time for job J j. Let the jobs be considered in the sequence π =(π(1),π(2),...,π(n)). The processing of job J π(1) on machine B may not start earlier than time τ π(1) max{α π(1) + a π(1),α π(1) + β π(1) }. For a job J π(j), 1 <j n, consider the time interval [τ π(j 1),τ π(j) ]. In this interval machine A performs the setup and the processing of job J π(j), while machine B performs the processing of job J π(j 1) followed by the setup of job J π(j). As above, the processing of job J π(j) on machine B may not start earlier than each of two events happens: (i) the processing of that job is completed on machine A; (ii) the setup phase of that jobs is completed on machine B. This implies that τ π(j) τ π(j 1) + max{α π(j) + a π(j),α π(j) + β π(j),b π(j 1) + β π(j) }. Since we want to find the schedule with the minimum makespan, we need to guarantee that the values τ π(j) are as small as possible for all j =1, 2,...,n. Defining b π(0) = τ π(0) =0,wecan write the smallest τ π(j) as where τ π(j) = τ π(j 1) + W π(j), j =1, 2,...,n. (19) W π(j) = max{α π(j) + a π(j),α π(j) + β π(j),b π(j 1) + β π(j) }. (20)