Simultaneous Job Scheduling and Resource Allocation on Parallel Machines

Transcription

1 Simultaneous Job Scheduling and Resource Allocation on Parallel Machines Zhi-Long Chen* Department of Systems Engineering University of Pennsylvania Philadelphia, PA February 1999 (Working Paper 99-04) *Supported in part by the University of Pennsylvania Research Foundation

2 ABSTRACT Most deterministic machine scheduling models assume that the processing time of a job on a machine is fixed externally and known in advance of scheduling. However, in most realistic situations, apart from the machines, it requires additional resources to process jobs, and the processing time of a job is determined internally by the amount of the resources allocated. In these situations, both the cost associated with the job schedule and the cost of the resources allocated should be taken into account. Therefore, job scheduling and resource allocation should be carefully coordinated in order to achieve an overall cost-effective schedule. In this paper, we study a parallel-machine scheduling model involving simultaneously job processing and resource allocation. The processing time of a job is non-increasing with the cost of the allocated resources. The objective is to minimize the total cost including the cost measured by a scheduling criterion and the cost of all allocated resources. We consider two particular problems of this model, one with the scheduling criterion being the total weighted completion time, and the other with that being the weighted number of tardy jobs. We develop a column generation based branch and bound method for finding optimal solutions for these NP-hard problems. The method first formulate the problems as set partitioning type formulations, and then solves the resulting formulations exactly by branch and bound. In the branch and bound, linear relaxations of the set partitioning type formulations are decomposed into master problems and single-machine subproblems and solved by a column generation approach. The algorithms designed based on this method are capable of solving the two problems with a medium size to optimality within a reasonable computational time. 1

3 1. Introduction Machine scheduling models have been the subject of a considerable number of papers in the last three decades. Most results on deterministic problems in this area assume that the processing time of a job on a machine is fixed externally and known in advance of scheduling. However, in most realistic situations, apart from the machines, it requires additional resources (e.g. manpower, electricity, and support equipment) to process jobs, and the processing time of a job is determined internally by the amount of the resources allocated. In these situations, both the cost associated with the job schedule and the cost of the resources allocated should be taken into account. Therefore, job scheduling and resource allocation should be carefully coordinated in order to achieve an overall cost-effective schedule. Work on machine scheduling models with processing times of jobs controlled by resource allocation was initiated by Vickson [25-26] and Van Wassenhove and Baker [24]. These models have received increasing attention during the last decade. Recent results include, among others, Nowicki and Zdrzalka [18-19], Panwalkar and Rajagoplan [20], Nowicki [17], Alidaee and Ahmadian [1], Trick [22], Daniels and Mazzola [12], Cheng and Kovalyov [9], Janiak and Kovalyov [14], Daniels, et al. [10-11], Cheng, et al. [7-8], and Chen, et al. [3]. There are two types of job processing times considered in the literature. In the first type, the continuous type, the processing time of a job is determined by the amount of a divisible resource (e.g. electricity) allocated and hence can vary continuously in a given interval. In the second type, the discrete type, the allocated resource is indivisible (e.g. manpower, and support equipment) and hence the processing time of a job can only have finitely many possible lengths. Except the papers by Daniels and Mazzola [12], Daniels, et al. [10-11], and Chen et al. [3] which study problems with the discrete type of processing times, all other above-cited results consider problems with the continuous type of processing times. Most of the existing papers in this area are dedicated to complexity analysis, and heuristic algorithms. Given the fact that most traditional scheduling problems without the 2

4 added complexity of resource allocation are already NP-hard (see, e.g. Pinedo [21]), it is not surprising that most scheduling problems with job processing times controlled by resource allocation are NP-hard (see, e.g. Chen, et al. [3]). To the best of our knowledge, except the work by Daniels and Mazzola [12] and Daniels, et al. [11], no research has been done in the literature on exact solution algorithms for NP-hard problems in this area. One of the results developed in Daniels and Mazzola [12] is a branch and bound algorithm for a flow shop problem with the discrete type of processing times where the objective is to minimize the makespan of the schedule subject to a known resource availability at any point of time. Their algorithm first enumerates all possible sequences of jobs and then, for each given job sequence, determines optimal assignment of resources to jobs and optimal start times of jobs. Daniels, et al. [11] studies a similar parallel machine problem with a prespecified assignment of jobs to machines. One of the results there is a branch and bound algorithm which first enumerates all possible resource allocation policies and then, for a fixed resource allocation policy, calculates lower bounds of the makespan of the schedule. It can be expected by their enumerative nature that these algorithms can only solve problems with a small size. In this paper we study a parallel machine scheduling model with job processing times controlled by resource allocation. We consider both the continuous type and discrete type of processing times. The objective is to minimize the total cost including the cost measured by a scheduling criterion and the cost of allocated resource. We focus on two particular problems with this model, one with the scheduling criterion being the total weighted completion time, and the other with that being the weighted number of tardy jobs. More precisely, our problems can be described as follows. There are a set of n jobs, N={1, 2,..., n}, to be processed on m identical parallel machines. Each job j N has a due date d j and a weight w j which are both externally given. Other than the machines, there is one additional resource needed for processing jobs. The amount of the resource allocated to a job determines the actual processing time of the job. In the case with continuous type of processing times, the actual processing time of each job j N, p j, could take any value in the prespecified interval [a j, b j ], depending on the amount of the allocated resource, where a j and b j are respectively the minimum and maximum possible processing times of job j. We assume that the actual processing time of a job is a decreasing linear function of 3

5 the cost of the allocated resource, that is, p j = b j - u j c j, where u j is a known parameter, and c j = (b j -p j )/u j is the cost of allocated resource. In the case with discrete type of processing times, the actual processing time of each job j N, p j, could take one of the k prespecified values: q j1, q j2,..., q jk with q j1 <q j2 <...<q jk, where k is a finite number and called the number of processing modes. To achieve these possible processing times, the costs of corresponding resources needed are respectively, v j1, v j2,..., v jk with v j1 >v j2 >...>v jk =0. Two sets of decisions, resource allocation and job scheduling, are involved simultaneously in this model. The decision of resource allocation determines actual processing times of the jobs, and the decision of job scheduling determines job sequences on the machines. A schedule is given if these decisions are specified simultaneously. In a given schedule, let p j be the actual processing time of job j, x j be the cost of the corresponding resource allocated to job j, and C j be the completion time of job j. Define U j = 1 if job j is tardy, i.e. C j >d j and 0 otherwise. Denote the total cost of resource allocated by TCR = Σ j N x j. Then our first problem, the total weighted completion time problem, is to find a schedule with the minimum total cost including total weighted completion time of jobs and total cost of resource allocated, i.e. Σ j N w j C j + TCR. Our second problem, the weighted number of tardy jobs problem, is to find a schedule with the minimum total cost including weighted number of tardy jobs and total cost of resource allocated, i.e. Σ j N w j U j + TCR. Following the well-known three-field notation for machine scheduling problems (see, e.g. Pinedo [21]), we denote the total weighted completion time problem with continuous type of processing times by P ct Σw j C j +TCR, and that with discrete type of processing times by P dt Σw j C j +TCR, where ct and dt represent, respectively, the cases with continuous type and discrete type of processing times. Similarly, we use P ct Σw j U j +TCR and P dt Σw j U j +TCR to denote the two cases of the weighted number of tardy jobs problem. Practical values of these problems are obvious. First, the scheduling criteria in these problems, total weighted completion time and weighted number of tardy jobs, are most commonly used in the scheduling applications. Secondly, necessary coordination of resource allocation and scheduling in these problems, as we mentioned in the beginning 4

6 of this paper, reflects real-world situations better than traditional scheduling models. Unfortunately, to the best of our knowledge, there are no existing results on these problems in the literature. It is clear that these two problems are both NP-hard because the corresponding problems without the resource allocation part are already NP-hard (see, e.g. Pinedo [21]). In this paper, we develop optimal branch and bound algorithms for the problems P ct Σw j C j +TCR, P dt Σw j C j +TCR, P ct Σw j U j +TCR, and P dt Σw j U j +TCR. Our algorithms are based on the column generation approach independently proposed by Van den Akker, et al. [23] and Chen and Powell [4] for traditional parallel machine scheduling problems without resource allocation. This approach has been shown to be the most computationally effective method for many parallel machine scheduling problems (Van den Akker, et al. [23], Chen and Powell [4-6], Lee and Chen [16], Chen and Lee [2]). The framework of this approach is as follows. First, a given parallel machine problem is formulated as a set partitioning type formulation with an exponential number of columns where each column represents a partial schedule on a single machine. Then, this set partitioning type formulation is solved to optimality by the branch and bound method. In each iteration of the branch and bound, a linear relaxation of the set partitioning type formulation (which may be modified by branching rules) is solved by applying the standard column generation procedure for large-scale linear programs (see, e.g. Lasdon [15]). In the course of this procedure, the linear relaxation problem is decomposed into a master problem which contains a limited number of columns and one or more subproblems which are single-machine scheduling problems. It is worth noting that whether this approach is effective for the underlying problem depends on the way we formulate the problem, the way we solve the resulting single-machine subproblems, and the way we select branching variables. In order to develop an effective algorithm, it is very important to exploit special structures and develop optimality properties of the underlying problem. The remainder of this paper is organized as follows. First, in Section 2, we formulate our problems as set partitioning type formulations. Then, in Section 3, we develop optimal branch and bound algorithms for solving these formulations based on the 5

7 column generation approach. Our computational results in Section 4 demonstrate that the algorithms are capable of finding optimal schedules for problems with up to 40 jobs and any number of machines within a reasonable computational time. Finally, we conclude the paper in Section Set Partitioning Type Formulations First, it is known (Vickson [25]) that, for the problem P ct Σw j C j +TCR, in an optimal schedule, the actual processing time of each job j, p j, is either the minimum or the maximum possible processing time, i.e. p j {a j, b j }, for all j N. This means that we can simply treat the problem P ct Σw j C j +TCR as the special case of the problem P dt Σw j C j +TCR with k=2 where each job j N has two possible processing times, q j1 =a j, and q j2 =b j, with the corresponding costs of resource needed v j1 =(b j -a j )/u j, and v j2 =0. Therefore, in the remainder of this paper, we will focus on the three problems P dt Σw j C j +TCR, P ct Σw j U j +TCR, and P dt Σw j U j +TCR, and not consider P ct Σw j C j +TCR as a separate problem. In the following, we give a set partitioning type formulation first for the problem P dt Σw j C j +TCR in Section 2.1, then for the problems P ct Σw j U j +TCR and P dt Σw j U j +TCR in Section Problem P dt Σw j C j +TCR In order to give an effective formulation, we first give an equivalent problem to this problem. For each job j N, we create k copies, denoted as, N(j) = {j(1), j(2),..., j(k)} Thus we now have a total of kn jobs, denoted as Q=N(1) N(2)... N(n). For each job j(i) Q, we define its weight w j(i) =w j, processing time p j(i) =q ji which is fixed and not controllable, and cost of resource v j(i) =v ji. Job j(i) corresponds to the ith possible processing time of job j. Then the problem P dt Σw j C j +TCR is equivalent to the problem of selecting a subset of jobs from Q and scheduling these selected jobs on the m machines so as to minimize the sum of the total weighted completion time and the total cost of resource associated with these jobs subject to the constraint that exactly one job from 6

8 each subset N(j), for each j N, is selected. In the following we focus on this equivalent problem instead of the original problem. It is clear that, in an optimal schedule for this equivalent problem, the jobs on each machine are scheduled in the non-decreasing order of the ratio p j(i) /w j(i). We define a partial schedule on a single machine as a schedule of a subset of jobs from Q on that machine where the jobs are in the non-decreasing order of the ratio p j(i) /w j(i). It is important to note that we allow multiple jobs from the same set N(j) to be present in a partial schedule, although such a partial schedule is not feasible for the problem. The reason will become clear later on. Let S = set of all partial schedules on a single machine l sji = 1 if job j(i) is covered in the schedule s S, and 0 otherwise, for j(i) Q h sj = Σ i {1,...,k} l sji, number of jobs from the subset N(j) covered in the schedule s S, for j N f s = total weighted completion time of the schedule s S g s = total cost of resource associated with the jobs in the schedule s S x s = 1 if the schedule s S is selected, and 0 otherwise Given a partial schedule s S, all the parameters l sji, h sj, for j(i) Q, j N, f s, and g s are known. Then this problem can be formulated as the following set partitioning type formulation. [SP1] Min ( f s + g s ) xs (1) s.t. s S h sj x s S s S s x s = 1, j N (2) m (3) x s = 0 or 1, s S (4) Here the constraint (1) is to minimize the sum of the total weighted completion time and the total cost of resource allocated in the selected partial schedules. The constraint (2) ensures that exactly one job from each N(j) is covered in these selected partial schedules. The constraint (3) means that at most m partial schedules are selected. Note that, although 7

9 we allow a partial schedule to contain multiple jobs from a subset N(j), the constraint (2) guarantees that no such partial schedules will be selected in the optimal schedule. However, as we will see later, the advantage of allowing such schedules to be included in S is that the linear relaxation problem of [SP1] is more tractable Problems P ct Σw j U j +TCR and P dt Σw j U j +TCR It is known in the literature (Cheng, et al. [8], Chen, et al. [3]) that, in an optimal schedule for these problems, on each machine, non-tardy jobs are scheduled before tardy jobs in the non-decreasing order of due dates, and the actual processing time of each tardy job j is the maximum possible processing time, i.e. p j = b j in the case of P ct Σw j U j +TCR, and p j = q jk in the case of P dt Σw j U j +TCR. Thus if job j is tardy then its contribution to the objective function is always w j no matter when and on which machine it is scheduled. Therefore, we do not need to consider tardy jobs in making scheduling decisions. Define a non-tardy partial schedule on a single machine to be the schedule of a subset of jobs from N on the machine in which all the jobs are non-tardy and in the nondecreasing order of their due dates. Let S = set of all non-tardy partial schedules on a single machine h sj = 1 if job j is covered in the schedule s S, and 0 otherwise, for j N g s = total cost of resource associated with the jobs in the schedule s S x s = 1 if schedule s S is selected, and 0 otherwise y j = 1 if job j N is tardy, and 0 otherwise Given a partial schedule s S, both the parameters h sj, for j N, and g s are known. Then both the problem P ct Σw j U j +TCR and the problem P dt Σw j U j +TCR can be formulated as the following set partitioning type formulation. [SP2] Min g x s s s S s.t. h x sj s S s s S + j N w (5) j y j + y j = 1, j N (6) x s m (7) 8

10 x s = 0 or 1, s S (8) y j = 0 or 1, j N (9) Here the constraint (5) is to minimize the sum of the weighted number of tardy jobs and the total cost of resource allocated. The constraint (6) ensures that each job is covered, either tardy or non-tardy. The constraint (7) means that at most m non-tardy partial schedules are selected. 3. Branch and Bound Algorithms In this section, we develop branch and bound algorithms for finding optimal solutions to the problems [SP1] (for P dt Σw j C j +TCR) and [SP2] (for P ct Σw j U j +TCR and P dt Σw j U j +TCR). The algorithms have the same general framework as follows. In the branch and bound tree, the root node is the linear relaxation problem of [SP1] (resp. [SP2]), denoted as [LSP1] (resp. [LSP2]) which is the same as [SP1] (resp. [SP2]) except that the constraint (4) is relaxed as 0 x s 1 for each s S (resp. the constraints (8) and (9) are relaxed as, respectively, 0 x s 1 for each s S, and 0 y j 1 for each j N). Each other node in the tree to be generated in the course of the branch and bound is the linear relaxation problem [LSP1] (resp. [LSP2]) with additional constraints imposed by branching rules. Starting from the root node, each iteration of the algorithm solves one node in the tree by the column generation approach (to be described in Section 3.1). It will either fathom this node or generate two child nodes by performing branching procedures based on some branching rules (to be described in Section 3.2). In the column generation approach, a linear relaxation problem [LSP1] (resp. [LSP2]), i.e. a branch and bound node, is decomposed into a master problem which is a linear programming problem and a subproblem which is a single-machine scheduling problem and can be solved by a pseudopolynomial dynamic programming algorithm. In branching procedures, we branch on variables in the subproblem level such that the additional constraints imposed on [LSP1] (resp. [LSP2]) by branching rules are implicitly added without changing the structure of [LSP1] (resp. [LSP2]). 9

11 3.1. Column Generation Approach As we mentioned earlier, each iteration of the branch and bound algorithms solves one linear relaxation problem [LSP1] or [LSP2]. To solve these problems, we use the idea of the standard column generation procedure (Lasdon [15]) for large-scale linear programming problems. This procedure starts with a limited number of columns in these formulations and generates necessary columns iteratively. In each iteration, we first solve the restricted version of the problem [LSP1] (resp. [LSP2]) (called restricted master problem) with the columns generated so far. Then we generate columns with most negative reduced costs by solving a single-machine scheduling problem (called singlemachine subproblem) that is closely related to the underlying parallel machine problem. Newly generated columns are then added to the restricted master problem which is then updated. When no new columns with negative reduced costs can be found, the procedure terminates and the problem [LSP1] (resp. [LSP2]) is solved. In the formulations [LSP1] and [LSP2], let the dual variable values be π j for index j in (2) and (6), and σ for (3) and (7). Then, in [LSP1] and [LSP2], the reduced cost r s of the column corresponding to a schedule s S is given respectively by the following formulas (10) and (11). r s = r s = f + g s s g s - j N - j N f + g hsjπ j - σ = s s h π - σ = s sj j g - j s - π j - σ (10) j( i) s π - σ (11) The single-machine scheduling problem involved in [LSP1] (resp. [LSP2]) is to find a partial schedule (resp. a non-tardy partial schedule) s S on a single machine with the minimum r s given by (10) (resp. (11)). In the column generation iteration, if the optimal schedule of the single-machine subproblem has a non-negative reduced cost, then all the columns that have not been included in the formulation have a non-negative reduced cost and no new column is generated and hence the master problem is solved. Otherwise, the column corresponding to the optimal schedule is added to the master problem as a new column and the column generation procedure continues. In the following, we propose algorithms for solving these subproblems. j 10

12 3.1.1 Solving Subproblem Involved in [LSP1] Chen and Powell [4] have proved the ordinary NP-hardness of the problem of finding a single-machine partial schedule with the minimum total weighted completion time minus total dual variable value of the jobs in the schedule. It is easy to see that the single-machine subproblem involved in [LSP1] is more general than the problem studied in Chen and Powell. Thus the subproblem involved in [LSP1] is at least ordinarily NPhard. In the following, we propose a pseudo-polynomial dynamic programming algorithm for solving this subproblem, and hence this problem is NP-hard in the ordinary sense. The optimality of the algorithm follows directly from the principle of optimality. DP Algorithm 1 Define P = Σ j N q jk. Note that P is the maximum possible total processing time on a single machine. For ease of notation, reindex all the nk jobs in Q as 1, 2,..., K, such that K=nk, and p 1 /w 1 p 2 /w 2... p K /w K, where p j = p l(h), w j = w l(h), and v j = v l(h) if j is the new index of the job whose initial index is l(h). For each job j {1, 2,..., K}, define B j to be the set of jobs that can be scheduled immediately before job j in a partial schedule s S, that is, B j = {1, 2,..., j-1}. Note that, in our branch and bound algorithm, branching procedures may update these sets. Define F(j, t) as the minimum reduced cost (defined by (10)) of a partial schedule containing a subset of jobs from {1, 2,..., j}, where the last job is job j and completed at time t. Initial conditions: F(0, t) = -σ if t=0, and otherwise. Recursive relations: 11

13 For j = 1, 2,..., K, and t = p j, p j +1,..., P, F(j, t) = min { F(i, t-p j ) + w j t + v j - π j i B j {0}} Optimal solution: min{f(j, t) j = 1, 2,..., K; t = 0, 1,..., P} Time complexity: O(n 2 P). We note that, in our branch and bound algorithm, branching rules (see details in Section 3.2) may impose restrictions on jobs a given job j can be scheduled immediately before, which is equivalent to updating the set B j. Clearly, the above algorithm still works after B j s are updated because we have explicitly incorporated B j s into the algorithm Solving Subproblem Involved in [LSP2] First, we note that, for both P ct Σw j U j +TCR and P dt Σw j U j +TCR, the singlemachine subproblem involved in [LSP2] is at least ordinarily NP-hard because the special case of this subproblem where all the jobs have the same due date and the processing time of each job is not controllable (i.e. a j =b j for each j N in the case of P ct Σw j U j +TCR, and k=1 in the case of P dt Σw j U j +TCR) is equivalent to the Knapsack problem, a known ordinarily NP-complete problem (Garey and Johnson [13]). In the following we propose a pseudo-polynomial dynamic programming algorithm for finding an optimal schedule of the subproblem for P ct Σw j U j +TCR. After a slight modification, the algorithm can be used to find an optimal schedule of the subproblem for P dt Σw j U j +TCR as well. Thus the subproblem is ordinarily NP-hard in both cases of P ct Σw j U j +TCR and P dt Σw j U j +TCR. DP Algorithm 2 Reindex jobs such that d 1 d 2... d n. Define P = Σ j N b j, d max = max{d j j N}, and t max =min(p, d max ). Note that t max is the maximum possible total processing time of a nontardy partial schedule on a single machine. For each j N, define B j to be the set of the jobs that can be scheduled immediately before job j in a non-tardy partial schedule on a single machine, that is, B j = {1, 2,..., j-1}. 12

14 Define F(j, t) as the minimum reduced cost (defined by (11)) of a non-tardy partial schedule containing a subset of jobs from {1, 2,..., j}, where the last job is job j and completed at time t. Initial conditions: F(0, t) = -σ if t=0, and otherwise. Recursive relations: For j = 1, 2,..., n, and t = a j, a j +1,..., t max, min {F(i, t-p j ) + (b j -p j )/u j - π j p j [a j, b j ], i B j {0}}, if t d j F(j, t) = (12), otherwise Optimal solution: min{f(j, t) j = 1, 2,..., n; t = 0, 1,..., t max } Time complexity: O(n 2 t max L), where L = max {b j -a j j N}. We note that this algorithm can be used to solve the subproblem for P dt Σw j U j +TCR if the recursive relation (12) is modified as follows: F(j, t) = min {F(i, t-q jl ) + v jl - π j l {1, 2,..., k}, i B j {0}}, if t d j, otherwise The resulting time complexity thus becomes O(n 2 kt max ). Also note that, in our branch and bound algorithm, branching rules (see details in Section 3.2) may impose restrictions on jobs a given job j can be scheduled immediately before, which is equivalent to updating the set B j. Clearly, the above algorithms still work after B j s are updated because we have explicitly incorporated B j s into the algorithms Branching Strategies In the branch and bound algorithms, each node in the branch and bound tree is a linear relaxation problem [LSP1] or [LSP2] with additional constraints imposed by branching rules. This linear relaxation problem is solved using the column generation 13

15 approach proposed in Section 3.1. In the branching part of the algorithm, if we follow the traditional branching scheme, one variable in the original formulation [SP1] or [SP2] is supposed to be selected as the branching variable in each iteration. However, since each variable in [SP1] and [SP2] represents a single-machine partial schedule, it is not easy to branch on such a variable. We propose to branch on variables in the subproblem level, which is described in detail in the following subsections separately for the problems P dt Σw j C j +TCR, P ct Σw j U j +TCR, and P dt Σw j U j +TCR Problem P dt Σw j C j +TCR For the problem P dt Σw j C j +TCR, a node in the branch and bound tree is a linear relaxation problem [LSP1] with possibly additional constraints imposed by branching policies. Given the solution of such a branch and bound node, x s for s S, define the following parameters, α j(i) = s S β j(i),r(h) = s S l δ sji x s s, j ( i ), r ( h ), for j(i) Q x s, for j(i), r(h) Q where l sji (defined in Section 2) is 1 if job j(i) is covered in schedule s and 0 otherwise, and δ s,j(i),r(h) is 1 if job j(i) is scheduled immediately before job r(h) in schedule s. A branching procedure is performed based on these parameters. There are two possible cases described in the following where branching procedures may be performed. Case 1: The solution of the branch and bound node is fractional, the integer part of its objective value is less than that of the best integer solution generated so far, and some of the α j(i) parameters are fractional. In this case, we branch down this node as follows. We first choose a parameter α j(i) closest to 0.5, for some j(i) Q. Then we create two child nodes (called Child 1 and Child 2), i.e. two new [LSP1] problems, such that the solution of Child 1 will result in α j(i) = 1 and that of Child 2 will result in α j(i) = 0. This can be accomplished by the following procedures. For Child 1, (i) Exclude all the jobs in N(j) except j(i) from the subproblem by removing these jobs from the job set Q in Algorithm 1. 14

16 (ii) Form the initial restricted master problem [LSP1] of Child 1 by selecting all the columns already generated in the parent node except the ones that contain one of the jobs in the set N(j)\{j(i)}. For Child 2, we exclude just one job, job j(i), from the subproblem and select columns of the parent node that does not contain job j(i). Case 2: The solution of the branch and bound node is fractional, the integer part of its objective value is less than that of the best integer solution generated so far, all the α j(i) parameters are integral, but some of the β j(i),r(h) parameters are fractional. In this case, we branch down this node as follows. We first choose a pair of jobs (j(i), r(h)) with the value β j(i),r(h) closest to 0.5. Then we create two child nodes, Child 1 and Child 2, such that the solution of Child 1 will result in β j(i),r(h) = 1 and that of Child 2 will result in β j(i),r(h) = 0. To this end, we perform the following procedures. For Child 1, (i) Exclude all the jobs in N(j)\{j(i)} and N(r)\{r(h)} from the subproblem by removing them from the job set Q in Algorithm 1. Also, in Algorithm 1, update the sets, B r(h) := {j(i)}, B u(v) := B u(v) \{j(i)} for all u(v) Q\{r(h)}, where these sets are defined in Algorithm 1 with new indices. (ii) Form the initial restricted master problem [LSP1] of Child 1 by selecting all the columns already generated in the parent node except the ones that contain at least one job from the set N(j) N(r)\{j(i), r(h)}, and the ones that contain at least one of the two jobs j(i) and r(h) but job r(h) is not scheduled immediately after job j(i). For Child 2, we simply update the set B r(h) := B r(h) \{j(i)} in Algorithm 1, and form the initial columns in the restricted master problem using all the columns in the parent node except the ones where job r(h) is scheduled immediately after job j(i). We note that, in a given branch and bound node, if all the α j(i) and β j(i),r(h) parameters are integral, then it can be proved that the solution of this node x s s must be integral. The proof follows directly from the one given in Chen and Powell [4] for a similar problem without resource allocation. Thus we do not give the details of the proof. 15

17 3.2.2 Problems P ct Σw j U j +TCR and P dt Σw j U j +TCR For the problems P ct Σw j U j +TCR and P dt Σw j U j +TCR, a node in the branch and bound tree is a linear relaxation problem [LSP2] with possibly additional constraints imposed by branching policies. Given the solution of such a branch and bound node, x s for s S, define the following parameters, α j = s S β ij = s S h δ sj x s sij x s, for j N, for i, j N where h sj (defined in Section 2) is 1 if job j is covered in schedule s and 0 otherwise, and δ sij is 1 if job i is scheduled immediately before job j in schedule s. A branching procedure is performed based on these parameters. Similarly to Section 3.2.1, there are two cases involving branching as follows. Case 1: The solution of the branch and bound node is fractional, the integer part of its objective value is less than that of the best integer solution generated so far, and some of the α j(i) parameters are fractional. In this case, we branch down this node as follows. We first choose a parameter α j closest to 0.5, for some j N. Then we create two child nodes (called Child 1 and Child 2), i.e. two new [LSP2] problems, such that the solution of Child 1 will result in α j = 1 and that of Child 2 will result in α j = 0. This can be accomplished by the following procedures. For Child 1, We do not need to update Algorithm 2. However, the initial restricted mater problem should be updated by removing the column corresponding to the variable y j. For Child 2, we remove job j from N in Algorithm 2 and form the restricted mater problem by columns of the parent node that does not contain job j. Case 2: The solution of the branch and bound node is fractional, the integer part of its objective value is less than that of the best integer solution generated so far, all the α j parameters are integral, but some of the β ij parameters are fractional. In this case, we branch down this node as follows. We first choose a pair of jobs (i, j) with the value β ij closest to 0.5. Then we create two child nodes, Child 1 and Child 2, such that the solution 16

18 of Child 1 will result in β ij = 1 and that of Child 2 will result in β ij = 0. To this end, we perform the following procedures. (i) For Child 1, in Algorithm 2, update the sets, B j := {i}, B h := B h \{i} for all h N\{j}, and in the initial restricted mater problem, remove the columns corresponding to the variables y i and y j and include all the columns already generated in the parent node except the ones that contain at least one of the two jobs i and j but j is not scheduled immediately after i. (ii) For Child 2, we simply update the set B j := B j \{i} in Algorithm 2, and form the initial columns in the restricted master problem using all the columns in the parent node except the ones where job j is scheduled immediately after job i. Similarly to Section 3.2.1, if all the α j and β ij parameters are integral, then it can be proved that the solution of this node x s s must be integral. The proof follows directly from the one given in Chen and Powell [4]. 4. Computational Results In this section, we report computational results of the branch and bound algorithms developed in Section 3. All the algorithms involved are coded in C and tested on a Sun Ultra 1 workstation (164 MHz). Linear programming problems involved in the column generation approach are solved by CPLEX Version 6.0. For the problem P dt Σw j C j +TCR, a test problem is generated by generating the following parameters: number of machines m, number of jobs n, number of processing modes k, and for each job j, a weight w j, k processing times, q j1,..., q jk, and k corresponding costs of resource allocation, v j1,..., v jk. For the problem P dt Σw j U j +TCR, besides these parameters, we need to generate a due date d j for each job j. For the problem P ct Σw j U j +TCR, we need to generate m, n, and for each job j, the parameters w j, a j, b j, u j, and d j. These parameters are generated as follows. (1) For the number of machines m, we use three cases m {2, 4, 6} in all the three problems. 17

19 (2) For the number of jobs, n, we use three cases, n {20, 30, 40}, in all the three problems. (3) For the number of processing modes, k, we use three cases, k {2, 4, 6}, in the problems P dt Σw j C j +TCR and P dt Σw j U j +TCR. Note that the problem P dt Σw j C j +TCR with k=2 is exactly the problem P ct Σw j C j +TCR. So we do not report computational results separately for the problem P ct Σw j C j +TCR. (4) For the weight of job j, w j, we use one case w j = U[1, 100] in the problem P dt Σw j C j +TCR, where U[x, y] is an integer uniformly drawn from the interval [x, y]; and one case w j = U[100, 1000] in the problems P ct Σw j U j +TCR and P dt Σw j U j +TCR. (5) For the k processing times of job j, q j1,..., q jk, in the problems P dt Σw j C j +TCR and P dt Σw j U j +TCR, we use one case which is generated in this order as follows: q j1 U[1, 50], and, for i=2,..., k, q ji = q j,i-1 + δ, where δ = U[1, 50/(k-1)]. (6) For the processing parameters of job j, a j, b j, in the problem P ct Σw j U j +TCR, we use one case a j = U[1, 50], and b j = a j + δ with δ = U[1, 50]. (7) For the k costs of resource allocation of job j, v j1,..., v jk, in the problem P dt Σw j C j +TCR, we use three cases which are generated in the reverse order as follows: v jk = 0, and for i=k-1,..., 1, v ji = v j,i+1 + ρδ, where ρ = U[1, αn/m], δ = U[1, 2500/(k-1)], and α has three cases α {0.5, 1.0, 2.0}. In the problem P dt Σw j U j +TCR, three cases of these parameters are generated exactly the same way except that the parameter δ = U[1, 100/(k-1)]. (8) For the resource-allocation parameter of job j, u j, in the problem P ct Σw j U j +TCR, we use three cases u j = U[1, 10α], where α has three cases α {0.5, 1.0, 2.0}. (9) For the due date of job j, d j, in the problems P ct Σw j U j +TCR and P dt Σw j U j +TCR, we use three cases d j = U[l j, r j ], where l j = a j in the earlier problem and l j = q j1 in the latter problem, and r j = max(l j, 50βn/m) with three cases of β {0.3, 0.6, 0.9}. 18

20 Note that the parameter α in all the three problems controls the relative average cost of resource allocation with respect to the underlying scheduling criterion, and the parameter β in the problems P ct Σw j U j +TCR and P dt Σw j U j +TCR controls the average job due date. Our computational experiments show that, (i) for the problems P dt Σw j C j +TCR and P ct Σw j U j +TCR, given all other parameters, the computational time required for solving a test does not vary much with the parameter α, and (ii) for the problem P dt Σw j U j +TCR, given all other parameters, the computational time does not vary much with the parameters k and α. This means that our algorithms for the problems P dt Σw j C j +TCR and P ct Σw j U j +TCR are robust on the parameter α (or equivalently, resource-allocation costs), and the algorithm for the problem P dt Σw j U j +TCR is robust on both parameters k and α (or equivalently, the number of processing modes, and resourceallocation costs, respectively). Thus, we will not report test results explicitly based on the parameter α for the problems P dt Σw j C j +TCR and P ct Σw j U j +TCR, and those explicitly based on the parameters k and α for the problem P dt Σw j U j +TCR. For the problem P dt Σw j C j +TCR, for each possible combination of the cases of the parameters m, n, and k, a total of fifteen test problems are generated randomly, five with α = 0.5, five with α = 1.0, and five with α = 2.0. Similarly, for the problem P ct Σw j U j +TCR, for each combination of the cases of the parameters m, n, and β, a total of fifteen problems are generated randomly, five with α = 0.5, five with α = 1.0, and five with α = 2.0. Finally, for the problem P dt Σw j U j +TCR, for each possible combination of the cases of the parameters m, n, and β, a total of forty five test problems are generated randomly, five for each of the nine joint cases of the parameters k {2, 4, 6} and α {0.5, 1.0, 2.0}. Tables 1, 2, and 3 show the test results for the problems P dt Σw j C j +TCR, P ct Σw j U j +TCR, and P dt Σw j U j +TCR, respectively. In Tables 1 and 2, each row summarizes the computational results based on the respective fifteen randomly generated test problems, and in Table 3, each row is based on the forty five randomly generated 19

21 problems. The performance measures shown in these tables are as follows. Columns (4) and (5) are, respectively, the average gap and the maximum gap in percentage between the linear relaxation optimal objective value of the root node in the branch and bound tree and the optimal integer objective value. This percentage reflects the tightness of the lower bound obtained by solving the linear relaxation of the original integer problem. Column (6) is the number of problems solved at the root node without any branching out of the fifteen or forty five tested problems. Columns (7) and (8) represent, respectively, the average number and the maximum number of nodes explored in the branch and bound tree for solving the problem. Note that at least one node (the root node) must be explored to solve any problem. Columns (9) and (10) represent, respectively, the average and the maximum cpu times in seconds consumed to solve the problem to optimality. From these tables, we can make the following observations: (1) The integrality gap is extremely small. Every problem tested has an integrality gap within 1.5%. Due to this, few nodes need to be explored in the branch and bound tree, and many test problems are solved at the root node without any branching. This result is consistent with the results obtained by Van den Akker [23], Chen and Powell [4-6], Lee and Chen [16], and Chen and Lee [2] in solving other parallel-machine scheduling problems using the column generation approach. (2) When n is fixed, a problem with a larger m can usually be solved faster than a problem with a smaller m. Note that, although not reported here, our experiment does show that problems with more than 6 machines require less cpu time than the corresponding problems reported in Tables 1, 2, and 3. This counter-intuitive result is also consistent with those obtained in the papers mentioned earlier. We think that this result is probably caused by the fact that, for fixed n, if m is smaller, then an ideal partial schedule on a machine should contain more jobs, and hence there are more possible ideal partial schedules and more columns may have to be generated in the course of the column generation, which thus takes more time. (3) Our algorithm is capable of solving problems with 40 jobs and any number of machines within a reasonable amount of cpu time. 20

22 5. Conclusion We have proposed branch and bound exact solution algorithms for the problems P dt Σw j C j +TCR, P ct Σw j U j +TCR, and P dt Σw j U j +TCR. The computational results have demonstrated that the algorithms are capable of solving problems with a medium size. An interesting topic for future research is to investigate other scheduling problems involving resource allocation decisions. We believe that the framework of the column generation methodology proposed in this paper can be applied to other classes of problems such as flow shop scheduling problems with resource allocation. The major challenge associated with the column generation method, as we have seen here, is its slow convergence for problems with a large ratio n/m. We are now developing techniques to overcome this degeneracy. 21

23 References [1] B. Alidaee and A. Ahmadian, Two parallel machine sequencing problems involving controllable job processing times, European Journal of Operational Research, 70 (1993), [2] Z.-L. Chen and C.-Y. Lee, Parallel machine scheduling with a common due window, Working Paper 98-12, Department of Systems Engineering, University of Pennsylvania, Philadelphia, PA , [3] Z.-L. Chen, L. Qing, and G. Tang, Single machine scheduling with discretely controllable processing times, Operations Research Letters, 21 (1997), [4] Z.-L. Chen, and W.B. Powell, Solving Parallel Machine Scheduling Problems by Column Generation. To Appear in INFORMS Journal on Computing [5] Z.-L. Chen, and W.B. Powell. A column generation based decomposition algorithm for a parallel machine scheduling just-in-time scheduling problem, European Journal of Operational Research, 116 (1999), [6] Z.-L. Chen, and W.B. Powell, Network representation, column generation and branch and bound for parallel machine scheduling with multiple job families. Working Paper 98-02, Department of Systems Engineering, University of Pennsylvania, Philadelphia, PA , [7] T.C.E. Cheng, Z.-L. Chen, and C.-L. Li, Single-machine scheduling with trade-off between number of tardy jobs and resource allocation, Operations Research Letters, 19 (1996), [8] T.C.E. Cheng, Z.-L. Chen, C.-L. Li, and B.M.-T. Lin, Scheduling to minimize the total compression and late costs, Naval Research Logistics, 45 (1998) [9] T.C.E. Cheng and M.Y. Kovalyov, Single machine batch scheduling with deadlines and resource dependent processing times, Operations Research Letters, 17 (1995), [10] R.L. Daniels, B.J. Hoopes, and J.B. Mazzola, An analysis of heuristics for the parallel-machine flexible-resource scheduling problem, Annals of Operations Research, 70 (1997), [11] R.L. Daniels, B.J. Hoopes, and J.B. Mazzola, Scheduling parallel manufacturing cells with resource flexibility, Management Science, 42 (1996), [12] R.L. Daniels and J.B. Mazzola, Flow shop scheduling with resource flexibility, Operations Research, 42 (1994),

24 [13] Garey, M.R. and D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Completeness. W.H. Freeman and Company, New York, [14] A. Janiak and M.Y. Kovalyov, Single machine scheduling subject to deadlines and resource dependent processing times, European Journal of Operational Research, 94 (1996), [15] L.S. Lasdon, Optimization Theory for Large Systems. MacMillan, New York, [16] C.-Y. Lee and Z.-L. Chen, Scheduling of jobs and maintenance activities on parallel machines, To appear in Naval Research Logistics, [17] E. Nowicki, An approximation algorithm for the m-machine permutation flow shop scheduling problem with controllable processing times, European Journal of Operational Research, 70 (1993), [18] E. Nowicki and S. Zdrzalka, A survey of results for sequencing problems with controllable processing times, Discrete Applied Mathematics, 25 (1990), [19] E. Nowicki and S. Zdrzalka, A bicriterion approach to preemptive scheduling of parallel machines with controllable job processing times, Discrete Applied Mathematics, 63 (1995), [20] S.S. Panwalker and R. Rajagopalan, Single-machine sequencing with controllable processing times, European Journal of Operational Research, 59 (1992), [21] M. Pinedo, Scheduling: Theory, Algorithms, and Systems, Prentice Hall, Englewood Cliffs, NJ, [22] M.A. Trick, Scheduling multiple variable-speed machines, Operations Research, 42 (1994), [23] J.M. Van den Akker, J.A. Hoogeveen, and S.L. van de Velde Parallel machine scheduling by column generation. Technical Report, Center for Operations Research and Econometrics, University Catholique de Louvain, Belgium. [24] L.N. Van Wassenhove and K.R. Baker, A bicriterion approach to time/cost tradeoffs in sequencing, European Journal of Operational Research, 11 (1982), [25] R.G. Vickson, Choosing the job sequence and processing times to minimize processing plus flow cost on a single machine, Operations Research, 28 (1980), [26] R.G. Vickson, Two single-machine sequencing problems involving controllable job processing times. AIIE Transactions, 12 (1980),

25 Table 1: Computational Results for the Problem P dt Σw j C j +TCR Problem n m k (1) (2) (3) Integrality gap avg max (4) (5) 0.00% 0.00% <0.01% 0.02% <0.01% 0.04% 0.00% 0.00% 0.00% 0.00% <0.01% <0.01% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% 0.00% <0.01% <0.01% 0.01% 0.03% <0.01% 0.01% <0.01% <0.01% <0.001% 0.01% <0.01% <0.01% <0.01% 0.01% 0.01% 0.04% <0.01% 0.02% <0.01% 0.01% 0.01% 0.01% <0.01% <0.01% <0.01% <0.01% <0.01% <0.01% 0.01% 0.02% 0.00% 0.00% <0.01% 0.01% Problems solved at root node (6) 15/15 10/15 9/15 15/15 15/15 14/15 15/15 15/15 15/15 15/15 13/15 8/15 10/15 11/15 7/15 3/15 7/15 9/15 5/15 8/15 5/15 6/15 13/15 9/15 6/15 15/15 11/15 b&b nodes avg max (7) (8) CPU time (s) avg max (9) (10)

26 Table 2: Computational Results for the Problem P ct Σw j U j +TCR Problem n m β (1) (2) (3) Integrality gap avg max (4) (5) 0.13% 0.58% 0.08% 0.12% 0.03% 0.09% <0.01% 0.02% 0.02% 0.07% 0.00% 0.00% 0.00% 0.00% <0.01% 0.01% 0.07% 0.15% 0.43% 0.80% <0.01% 0.01% 0.10% 0.28% 0.03% 0.13% 0.02% 0.08% 0.12% 0.26% 0.09% 0.29% <0.01% 0.02% 0.03% 0.08% 0.21% 0.32% 0.05% 0.20% 0.08% 0.19% 0.20% 0.65% 0.02% 0.07% 0.10% 0.23% 0.12% 0.30% 0.02% 0.11% <0.01% 0.02% Problems solved at root node (6) 5/15 11/15 9/15 11/15 6/15 15/15 15/15 12/15 6/15 0/15 2/15 0/15 3/15 0/15 0/15 10/15 6/15 1/15 6/15 0/15 4/15 4/15 0/15 0/15 5/15 0/15 0/15 b&b nodes avg max (7) (8) CPU time (s) avg max (9) (10)