IIE Transactions (2004) 36, 1107–1124 C “IIE” Copyright ISSN: 0740-817X print / 1545-8830 online DOI: 10.1080/07408170490500681
Improving scheduling robustness via preprocessing and dynamic adaptation ERHAN KUTANOGLU1 and S. DAVID WU2 1
Operations Research and Industrial Engineering Graduate Program, Department of Mechanical Engineering, The University of Texas at Austin, 1 University Station C2200 ETC 5.160, Austin, TX 78712, USA E-mail:
[email protected] 2 Department of Industrial and Systems Engineering, Lehigh University, 200 W. Packer Ave., Bethlehem, PA 18015, USA E-mail:
[email protected] Received September 2002 and accepted December 2003
We study methods to improve scheduling robustness under processing time variation. We propose a two-stage scheme that preprocesses the scheduling data to create a skeleton of a schedule and then completes it over time through dynamic adaptation. We focus our attention on the classical job shop scheduling problem. Preprocessing starts at the beginning of the planning period (at the time of scheduling) when a priori information becomes available on processing time uncertainty. We first decompose the job shop scheduling problem into network-structured subproblems using Lagrangian relaxation. For each subproblem, we introduce stochastic constraints that capture the processing time uncertainty. We incorporate the stochastic information in such a way that the subproblems retain their efficient network structure. Using a subgradient search algorithm, we iteratively improve the lower and upper bounds obtained from the Lagrangian relaxed problem, which produce a partial sequence of critical operations. This so-called Lagrangian ranking defines a preprocessed schedule where the complete scheduling is determined dynamically over time, adapting to changing shop conditions. We test the robustness of the two-stage scheme through extensive computational experiments. We show that the scheme significantly outperforms deterministic scheduling methods and dynamic dispatching rules with minimal computational burden.
Nomenclature = job index, i = 1, . . . , N where N is the number of jobs; j = operation index, j = 1, . . . , ni where ni is the number of operations of job i; k = machine index, k = 1, . . . , M where M is the number of machines; t = time index, t = 1, . . . , T where T is the number of time periods in the planning horizon; Wi = weight or tardiness penalty of job i; di = due date of job i; Ci = completion time of job i; Ti = tardiness of job i, max {0, Ci − di }; mij = machine required for operation j of job i; pij = processing time of operation j of job i; Cij = completion time of operation j of job i; Sij = starting time of operation j of job i.
i
1. Introduction We study scheduling robustness in a production environment where frequent changes and disturbances in shop conC 2004 “IIE” 0740-817X
ditions are to be expected. These uncertain events complicate the role of production scheduling since two conflicting goals must be reconciled: first, the system must perform at a globally satisfactory level for efficient usage of resources even under these changes, and second, the system must allow sufficient flexibility for changes and adjustments. To achieve the first goal of high quality global performance, a well-planned a priori schedule is usually required. A static scheduling method is typically used to create a finetuned, potentially optimal schedule at the beginning of the planning horizon. The static approach typically generates a detailed schedule assuming perfect information about the system’s current and future states. In reality, disturbances and changes in the system could render this static schedule difficult, if not impossible, to follow. When updates are made to accommodate the system disturbances, the overall scheduling performance is likely to deteriorate. Thus, a schedule “optimized” with respect to what is known at the planning time may perform poorly under these changing conditions. To achieve the second goal of flexibility, dynamic dispatching policies are typically used, where scheduling decisions are made throughout the course of production. This dynamic scheduling approach usually utilizes myopic
1108 priority indices and greedy heuristics, which may lead to poor global performance. However, its inherent flexibility and ability to utilize up-to-date potentially statedependent information makes dynamic scheduling a practical tool in uncertain environments. For example, Lawrence and Sewell (1997) show empirically that the performance of “optimized” static schedules may deteriorate rapidly with the processing time uncertainty, and that simple dynamic dispatching heuristics may provide a far superior performance. Another similar study by Kutanoglu and Sabuncuoglu (2001) reports similar observations when considering uncertainties in job processing times and machine availability. In this paper, we propose to address scheduling robustness by a method that reconciles the benefits of static and dynamic scheduling. We shift the focus of a priori scheduling to identifying decisions that are critical to global performance under the presence of random changes and disturbances. We find and optimize these critical decisions using a priori stochastic information and Lagrangian relaxation, which partially solves the scheduling problem. We call this stage preprocessing, which is followed by the so-called dynamic adaptation stage, where the unsolved scheduling decisions unfold over time using a dynamic scheduling approach. Treating scheduling problems in uncertain environments did not attract much attention in the literature until the early 1980s. One approach is to reschedule all the jobs from scratch every time an uncertain event occurs (Muhlemann et al., 1982; Yamamoto and Nof, 1985; Church and Uzsoy, 1992; Wu et al., 1992, 1993; Baptiste and Favrel, 1993). Researchers have also proposed schedule repair methods that compute a temporary schedule after each machine breakdown that attempt to bring the system back to schedule in a finite amount of time. The “match-up scheduling” method proposed by Gallego (1988a, 1988b) and Bean et al. (1991) belongs to this category. A similar schedule update heuristic that uses the second-moment information for uncertain processing times is proposed by Maddox and Birge (1992). Instead of repairing a prespecified schedule, Mehta and Uzsoy (1997) propose a method that inserts idle times into the schedule in anticipation of schedule disruptions. Another approach is to split the scheduling activity into planning and dispatching stages. The planning stage computes the pricing or resource usage costs using global information, while the dispatching phase makes use of the resource pricing and up-to-date shop conditions, and deals with uncertainties. This approach is both general and effective as demonstrated by Morton et al. (1986, 1988) and Roundy et al. (1991). A similar approach by Wu et al. (1999) partitions the operations of all jobs into an ordered sequence of subsets in the planning phase. This identifies and resolves the supposedly critical scheduling decisions through a graph-theoretic preprocessing. The second stage completes the schedule dynamically using a dispatching heuristic.
Kutanoglu and Wu The approach described in this paper is parallel to the two-stage methods in the last group of papers, as we first preprocess the problem via stochastic analysis to create a partial ranking of jobs first, and then adapt these decisions and make the remaining scheduling decisions as the real events unfold in real-time. This paper focuses on the issue of scheduling robustness. For the purposes of this study, we define “robustness” from the viewpoint of a scheduling procedure. A procedure or an algorithm is said to be more robust than an alternative if the schedules it generates achieve better performance (as defined by the objective function) under the same set of random disturbances and changes. For other related definitions of robustness, we refer the reader to Leon et al. (1994) and Kouvelis and Yu (1996).
2. The proposed scheduling scheme We propose a two-stage approach to achieve scheduling robustness: (i) preprocessing: based on the knowledge of the problem instance and data uncertainty, resolve a subset of sequencing decisions critical for the overall scheduling performance; and (ii) dynamic adaptation: complete actual scheduling (timing and sequence) using the most current data when uncertainties unfold in real-time. We use the job shop scheduling problem to present and test the methodology. In the preprocessing stage, we use an Integer Programming (IP) formulation of the Job shop Scheduling Problem (JSP). Instead of using the IP model to generate a detailed static schedule, we use it to analyze the criticality of scheduling decisions. First, we decompose the JSP to job-level subproblems using the Lagrangian relaxation of the machine capacity constraints. This results in job-level subproblems, each with a special network structure, which can be solved efficiently. Second, we reformulate each job-level subproblem to include chance constraints that capture processing time uncertainty, while keeping the special network structure intact. Although capacity-infeasible as a whole, the solution of the relaxed problem (the combination of job-level schedules) produces a lower bound for the corresponding (chance-constrained) JSP. Next, we iteratively improve the Lagrangian lower bound using a subgradient optimization search algorithm. Although capacity-infeasible, the lower bound solution has useful information regarding the overall criticality of jobs. Therefore, in each subgradient iteration, we also compute the so-called Lagrangian ranking among the jobs based on their position in the lower bound schedule. The estimated performance of each Lagrangian ranking is captured with a feasibility restoration heuristic. When the subgradient search algorithm stops, we report the Lagrangian ranking that produces the best estimated performance. Finally, we preprocess the scheduling instance by prioritizing the jobs according to their Lagrangian ranking, i.e., a subset of operations are sequenced based on their criticality captured in the best reported Lagrangian ranking.
1109
Improving scheduling robustness In the dynamic adaptation stage, the preprocessed schedule is used as an input to be followed in real time, while the remaining prioritization of jobs is done dynamically over time during which processing times can vary. Hence, the preprocessed schedule is implemented and the remaining schedule is generated using the actual (realized) processing times. The above scheme can be viewed as a variation of the Preprocess-First-Schedule-Later (PFSL) scheme proposed by Wu et al. (1999). Wu et al. (1999) used a branch-andbound algorithm for the a priori analysis and a dynamic dispatching rule for detailed scheduling.
3. The robust scheduling methodology In this section, we formalize the proposed scheduling scheme by first introducing the classical JSP model (in Section 3.1) we use for the analysis. We then describe the Lagrangian relaxation of JSP (Section 3.2), and introduce the chance constraints which capture the processing time uncertainty (Section 3.3). We provide a description of a scaling scheme used to reduce computational burden and define the Lagrangian ranking (Section 3.5), and detail a specialized version of the subgradient search algorithm (Section 3.6). We end the section by an outline of the overall scheduling scheme with the added technical details.
(JSP) min
1 − Xi,ni ,t
Wi
Xijt =
1 if operation j of job i has started by time t, (1) 0 otherwise.
The JSP can be formulated as follows (we set the variables with out-of-range indices to zero):
,
(2)
subject to
Xi,j,t
Xi,j,t+1 ≥ Xi,j,t , ∀i, j, t < T, Xi,j,t ≤ Xi,j−1,t−pi,j−1 , ∀i, j > 1, t, − Xi,j,t−pij ≤ 1, ∀k, t,
(3) (4) (5)
i,j:mij =k
Xi,j,t ∈ {0, 1} , ∀i, j, t.
(6)
The first set of constraints (3) makes sure that once an operation is started, it remains so in all subsequent time periods. This is due to the definition of decision variables Xijt and the non-preemption requirement. Constraints (4) state that an operation cannot start until its previous step (predecessor) is completed. Finally, the machine capacity constraints (5) state that at most one job can be processed on a particular machine in a given time period. The objective function (2) is the total weighted tardiness derived from the fact that cost of Wi is incurred for each time period after di during which job i has not been completed. The objective function can be rewritten as follows: Wi Wi T − di + pi,ni 1 − Xi,ni ,t = t>di −pi,ni
i
−
3.1. The job shop scheduling model
t>di −pi,ni
i
i
We consider the classical JSP where a set of jobs is to be completed on multiple machines. Each job consists of a series of operations that represent the production steps of the job. Due to processing requirements, the operations of a job are subject to (serial, or as sometimes called, linear) precedence constraints. Each production step (operation) requires a specific machine and once the processing of an operation starts it cannot be preempted by any other operation. The collection of operation processing times and their corresponding machine requirements represent the job routing. Each machine can only process one operation at a time. This requirement defines the machine capacity constraints. Each job has a due date and a weight, and the objective is to find a schedule which minimizes the total weighted tardiness. Although there are alternative ways to formulate the problem (see Pinedo (2001) for additional discussion), we state the time-indexed IP formulation of the JSP due to Pritsker et al. (1969). In this formulation the decision variables (Xijt ) are defined as follows:
i
where
wijt =
Wi 0
if j = ni and otherwise.
j
wijt Xijt
(7)
t
t > di ,
(8)
Since the first term in the objective function (7) is a constant, we represent it as A = i Ai where Ai = Wi (T − di + pi,ni ). We know that the processing time information is among the most critical inputs in solving scheduling problems. This is particularly true when a regular performance measure such as Equation (2) is considered. Any change in processing times is likely to affect the solution and its corresponding weighted tardiness value. 3.2. Lagrangian relaxation We now consider the Lagrangian relaxation (LR) for the JSP formulation as previously implemented by Roundy et al. (1991). When we relax the machine capacity constraints (5) of (JSP) with non-negative Lagrange multipliers λkt ; ∀k, t, we obtain the following Lagrangian relaxation problem: (LRλ ) Ai + λmij ,t − λmij ,t+pij − wijt Xijt , min i
i
j
k
t
t
λkt , −
(9)
1110
Kutanoglu and Wu
subject to
3.3. Chance constraints Xi,j,t+1 ≥ Xi,j,t ∀i, j, t < T, Xi,j,t ≤ Xi,j−1,t−pi,j−1 ∀i, j > 1, t, Xi,j,t ∈ {0, 1} ∀i, j, t.
(10) (11) (12)
We decompose (LRλ ) into independent job-level subproblems as follows: v(LRλ,i ) − λkt (13) v(LRλ ) = i
k
t
where v(LRλ,i ) denotes the value of optimal solution of the subproblem for job i (LRλ,i ): λmij ,t − λmij ,t+pij − wijt Xijt , v(LRλ,i ) = min Ai + j
We now construct a chance-constrained model for each joblevel subproblem in anticipation that the operational processing times are subject to random changes. We assume that there is a priori information about the processing time distribution, which can be estimated (and updated) using historical data. Chance constrained programming was first proposed by Charnes and Cooper (1959). We use chance constraints to capture the processing time variation. In job-level subproblems, precedence constraints are the only constraints that are affected by the processing time uncertainty. For a specific job i, the precedence constraints are as follows: Xijt ≤ Xi,j−1,t−pi,j−1 ,
t
(14) subject to Xi,j,t+1 ≥ Xi,j,t ∀j, t < T, Xi,j,t ≤ Xi,j−1,t−pi,j−1 ∀j > 1, t, Xi,j,t ∈ {0, 1} ∀j, t.
(15) (16) (17)
∀j > 1, t.
Since processing times pij occur in indices in Constraints (22), it is difficult to convert these to chance constraints in their current form. However, we can obtain the start and completion times (Sij and Cij ) of each operation as follows: Sij = T − Xijt + 1, and Cij = T − Xijt + pij , t
The subproblems satisfy the integrality property; in fact they are dual of a specially structured maximum flow network problem (Roundy et al., 1991). We can therefore relax the binary constraints (17) as below: Xijt ≤ 1, Xijt ≥ 0,
∀j, t, ∀j, t.
(18) (19)
t
(23) and rewrite the precedence constraints (22) as follows: Cij ≤ Si,j+1 − 1,
XijT ≤ 1, Xijt ≥ 0,
∀j, ∀j, t.
(20) (21)
Note that constraints (20) are defined only for T, as opposed to the original constraints (18), which are defined for all t = 1, . . . , T. Since the dual to (LRλ,i ) is a max-flow problem on a network, we can use specialized dual network-flow algorithms to solve each job-level subproblem. As the Lagrangianrelaxed problem satisfies the integrality property, the LR lower bound is no stronger than the lower bound generated by JSP’s Linear Programming Relaxation (LPR). However, from a computational point of view, the LR subproblems are easier to solve due to their decomposed network-flow structure. More importantly, although LR and LPR may provide the same lower bound value, they do not provide the same lower bound solution. In general, the integer LR solution is much closer to a fully feasible solution (partially resolved operation sequences with some resource conflicts) than a fractional LP solution. This is critical as we use the JSP model to establish partial ranking among operations (Lagrangian ranking). The fractional LPR solution is not useful in this regard.
∀j < ni ,
or equivalently Xijt − Xi,j+1,t ≥ pij , t
Repeated application of first set of constraints (15) leads us to the following constraints instead of relaxed constraints (18) and (19):
(22)
∀j < ni .
(24)
(25)
t
Assuming that pij represents the random processing times, we incorporate probabilistic processing times as follows: Suppose the desired confidence level for the stated precedence constraints (25) to hold is βij . Then we have the following chance constraints: Xijt − Xi,j+1,t ≥ pij ≥ βij , ∀j < ni . (26) P t
t
These chance-constrained precedence constraints state that “the probability that there is ‘enough’ time between the completion times of operations j and j + 1 of job i is βij .” Using the known probability distribution of the processing times pij in chance constraints (26), we find the following deterministic equivalents for them: Xijt − Xi,j+1,t ≥ Pij , ∀j < ni , (27) t
t
where Pij is the smallest number satisfying: P[pij ≤ Pij ] ≥ βij
or
Fij [Pij ] ≥ βij ,
(28)
where Fij [·] is the corresponding cumulative distribution function of pij . Specifically, if the processing time pij is known to be uniformly distributed between aij and bij , then the corresponding adjusted processing time Pij = aij + βij (bij − aij ). If pij is predicted to be normally distributed
1111
Improving scheduling robustness with mean p¯ij , and variance σij2 , N(p¯ij , σij2 ), then Pij = p¯ij + zβij σij where zβij is the left-tail βij -fractile of the standard normal distribution. We now convert the chance constraint equivalents into their original forms with the adjusted processing times included in indices (similar to the transformation from Equation (22) to Equation (25) above, this time in the opposite direction). This results in a job-level subproblem (referred as LRCλ,i for LR with chance constraints) that minimizes the subproblem objective defined in Equation (14) subject to the chance-constrained precedence constraints, in addition to the non-preemption constraints and the bound constraints that are in the original subproblem. Thus, the job-level subproblem with chance constraints for job i, LRCλ,i , can be stated as follows: v(LRCλ,i ) = min Ai + λmij ,t − λmij ,t+Pij − wijt Xijt , j
t
(29) subject to Xi,j,t ≤ Xi,j−1,t−Pi,j−1
∀j > 1, t
and the constraints (15), (20) and (21). The revised Lagrangian objective is: v(LRCλ ) = v(LRCλ,i ) − λkt . i
k
(30)
(31)
t
algorithm are given in Section 3.6. A more generic discussion on subgradient optimization can be found in Parker and Rardin (1988) and Wolsey (1998). An important aspect of the proposed scheduling scheme is that we use the Lagrangian relaxation and its subgradient search as a means to determine a partially established sequence among operations. The sequence can be only partially defined since the Lagrangian-relaxed solution does not resolve all resource conflicts between operations, i.e., it is capacity-infeasible. We define this Lagrangian schedule as follows: Definition 1. (Lagrangian schedule.) Given a Lagrangian multiplier vector λ, a Lagrangian schedule is the collection of job-level solutions characterized by the solution vector X ≡ X1 , . . . , XN , where Xi = (Xijt )j=1,...,ni ,t=1,...,T is the solution vector of job subproblem LRCλ,i . Note that the Lagrangian schedule satisfies all job-level (non-preemption and chance-constrained precedence) constraints, but there exist resource conflicts among these joblevel schedules. Thus, the Lagrangian schedule is a lower bound of the original (JSP) with chance constraints. The Lagrangian schedule provides a precise characterization of the provided problem instance, through which we are to define a sketch of the ultimate schedule. In the following, we specify the information we extract from the Lagrangian schedule with the notion of Lagrangian ranking.
We can still solve each job-level subproblem using a dual network algorithm because the structure of the chanceconstrained job models is the same as the deterministic counterparts.
Definition 2. (Lagrangian ranking). Consider two operations (i, j) (of job i) and (i , j ) (of job i ) which require the same machine (i.e., mij = mi j ) for processing. Suppose (i, j) starts earlier than (i , j ), in the Lagrangian schedule, i.e., Sij < Si j , as defined by Xi and Xi .
3.4. Lagrangian ranking
1. If there is no resource conflicts between (i, j) and (i , j ) in the Lagrangian schedule, i.e., (Xi,j,t − Xi,j,t−Pij ) + (Xi ,j ,t − Xi ,j ,t−Pi j ) ≤ 1 for all t, then the operations are said to be strongly ranked, where (i, j) has higher ranking than (i , j ). 2. Otherwise, the operations (i, j) and (i , j ) are said to be weakly ranked, where (i, j) has higher ranking than (i , j ).
We use a subgradient search algorithm for the Lagrangian relaxation problem with chance constraints. The subgradient optimization starts with a set of initial values for the multipliers λ = λ0 . Then the algorithm generates a sequence {λr } over the iterations r = 1, . . . , K by the rule: λrkt+1 = max 0, λrkt + sr gkt (X r ) , (32) where sr is an appropriately selected step size in iteration r and gkt (X r ) is the subgradient of the capacity constraint of machine k for time period t, calculated at an optimal solution X r of (LRCλr ): r r gkt (X r ) = Xi,j,t −1 (33) − Xi,j,t−P ij i
j:mij =k
Step size sr is calculated as follows:
UB − v(LRCλr ) sr = αr 2 r , k t gkt (X )
(34)
where αr is a scalar satisfying 0 < αr ≤ 2 and UB is an upper bound value for (JSP) which can be updated over the iterations. Details of the implemented subgradient search
As stated in the definition, operation pairs with no resource conflicts in the Lagrangian schedule are strongly ranked. Note that the reverse of the strong ranking is also strong. The same is also true for the weak ranking. Operation pairs that are neither strongly nor weakly ranked are considered unranked. (Note that these unranked operations are at different machines, which do not need explicit ranking anyway.) Using the definition of Lagrangian ranking we may define a preprocessed scheduling instance by imposing a precedence constraint between each strongly ranked pair of operations. These precedence constraints dictate that the higher-ranked operations will be processed before the lower-ranked operations in the final schedule. The weakly ranked pairs of operations represent scheduling decisions to be made during the dynamic adaptation phase, where
1112 the priority established by weak ranking may be considered (among other alternatives) as a dispatching heuristic. That is, the dynamic adaptation phase may use the “weak ranking” to complete the schedule. In the implementation of the approach, we compute a Lagrangian ranking from the Lagrangian schedule in every iteration, estimate its dynamic adaptation performance using a feasibility restoration heuristic that will be explained later, and the ranking with the best estimated performance over the iterations is reported. 3.5. Scaling and other implementation choices 3.5.1. Scaling In the JSP formulation described above, the number of discrete time periods T in the planning horizon directly affects the number of decision variables and constraints, and thus has a significant impact on the computational tractability of the model. The subproblem for job i has ni T variables and roughly 2ni T constraints. In each iteration of the subgradient optimization, we solve N such problems. Note that T depends on the number of jobs and their processing times; a problem instance with many “long” jobs will require a long planning horizon, thus a large T. It is possible to scale (down) the processing times by dividing them by a scaling factor. (Note that there is no need for scaling if there is a small number of jobs with small number of operations, each with relatively short processing times.) In addition to reducing computation time, the scaling factor leads to several interesting additional benefits. First, since the JSP model is used to preprocess a partial schedule (rather than to solve for a complete schedule) for the instance at hand, we are more interested in analyzing the aggregate structure of the problem rather than the minuteto-minute details. The scaling factor allows us to adjust the “resolution” of the analysis. Second, for regular performance measures (such as weighted tardiness) a unique schedule can be determined by the operation ranking at each machine. For example, one does not need to know the actual processing times to implement a shortest processing time dispatching rule; knowing the relative processing time ranking would suffice. Thus, in theory, one could maximize the scale of the processing times so long as the operational ranking is still distinguishable. Finally, having scaled processing times might even be beneficial when processing times are uncertain, since a scaled value may represent several possibilities in the unscaled version, which could provide additional robustness. In the computational experiments, we study the effects of scaling on computation time and on scheduling performance and then fix the scaling factor at a certain value. (We note that using a this scaling scheme is not the same as choosing different units of processing times. The scaling factor only controls the resolution of the model. The stochastic realizations of processing times, and the ultimate performance measures dur-
Kutanoglu and Wu ing the dynamic adaptation are calculated using the original scale. In related studies (Kutanoglu and Wu, 2002; Ling and Kutanoglu, 2002), we investigate the effect of scaling for deterministic job-shops and resource-constrained project scheduling problems). 3.5.2. Other implementation choices To improve the lower bound generated by the Lagrangian schedule and to produce high-quality Lagrangian rankings, we take advantage of the iterative nature of the subgradient search algorithm. Every iteration, the current strong ranking which is by itself a partial schedule is completed using a feasibility restoration heuristic that resolves the conflicts and fixes the unresolved rankings. The weighted tardiness performance of the completed schedule serves as an evaluation measure of the potential that the partial schedule has in its estimated second stage (dynamic adaptation) performance. The partial schedule that produces the best estimated performance over all iterations is ultimately released and used as a basis for the dynamic adaptation. We use a dynamic priority dispatching-based approach for the feasibility restoration heuristic. As the strong ranking obtained from the Lagrangian schedule provides a partial schedule, all we need is to prioritize the weakly ranked operations. We consider several implementation choices to formalize the heuristic: 1. The choice for prioritizing the weakly ranked operations: We follow the strongly ranked sequence as is, while sequencing the weakly ranked operations using one of two alternatives: (i) the priorities established by the weak ranking; or (ii) a dispatching heuristic such as the Apparent Tardiness Cost (ATC) rule (Vepsalainen and Morton, 1987), i.e., the former follows both the strong and the weak Lagrangian ranking, whereas the latter replaces the weak ranking with dynamic ATC dispatching. 2. Active versus non-delay scheduling: An operation can only be processed when its machine becomes available, and its predecessor operation is completed. When a machine becomes available, it is possible that a high-priority operation (as defined in the previous item, prioritizing weakly ranked operations) is not readily available for processing (its predecessor is not complete). In this case, we have the option of applying, (i) active scheduling (stay idle till its predecessor is complete); or (ii) non-delay scheduling (process the next high-priority operation that is available immediately). 3. The choice for processing times: We consider two alternatives: (i) adjusted scaled processing times; or (ii) unscaled mean processing times. While the former provides better alignment with the model that drives the Lagrangian relaxation and its subgradient search procedure, the latter could provide better estimation of the potential performance in the unscaled “world.” Finally, the Lagrangian ranking that yields the best estimated performance (the lowest total weighted tardiness)
1113
Improving scheduling robustness over all the subgradient iterations is released for schedule preprocessing, where the strongly ranked operations are prioritized. This is released to the shop, after which the dynamic adaptation starts. We again follow the reported strong ranking as is and dynamically complete the rest of the schedule in real-time using the same implementation choices (except for processing times, as these are being realized) considered in the feasibility restoration heuristic (active versus non-delay scheduling, and weak ranking versus ATC). At this stage, realizations of processing times will determine the actual operation completion times which in turn might affect the availability of operations and hence their actual order in the resulting schedule. While using the Lagrangian schedule for a lower bound, and the feasibility restoration heuristic to estimate the performance of the Lagrangian ranking, we also compute an upper bound for the “scaled” JSP problem with chance constraints to be used in the update of the Lagrange multipliers of Equation (34). For this, we use the feasibility restoration heuristic outlined above with the same alternative implementation choices for 1 and 2, along with one fixed obvious choice for 3, adjusted scaled processing times.
3.6. The subgradient search algorithm In this section we describe the main computational component of the two-phase scheduling scheme, the subgradient search algorithm. The subgradient search algorithm updates the Lagrangian multipliers of the relaxed JSP by iteratively improving the lower and upper bounds computed from the N job-level-subproblems. The algorithm terminates after a fixed number of iterations and returns the Lagrangian ranking that produces the best estimated second-stage performance. In the following, we describe the algorithm in detail. Step 1. Read input data: the number of jobs N, the number of machines M, job weights Wi , due dates di , mean (unscaled) processing times pij , machine requirements mij , for all i and j. Read the probability distribution information (aij and bij in the uniform case, σij2 in the normal case). Enter the implementation choices: (weak ranking or ATC-ranking, active or non-delay scheduling, scaled adjusted processing times or unscaled mean processing times) Step 2. Calculate adjusted processing times Pij for constraints (30) according to the distribution type and the confidence level βij . Scale the adjusted processing times to obtain scaled processing times Pijs if needed. Scale the due dates accordingly. Step 3. Upper bound initialization: Generate an active or a non-delay schedule using a dispatching rule (such as ATC) and the scaled processing times. Use the upper bound schedule to set a reasonable planning horizon, T.
Step 4. Initialize the Lagrange multipliers λkt , the iteration counter r , and the scalar parameter αr . Step 5. Main step: Perform the subgradient search for r = 1, . . . , K iterations. 5.1. Compute the Lagrangian lower bound (LBr ): solve the job-level subproblems (29), (30), (15), (20) and (21) using scaled processing times Pijs . This results in a capacity-infeasible Lagrangian schedule with objective value v(LRCλr ) which provides a lower bound for iteration r . 5.2. Use the feasibility restoration to compute an upper bound (UBr ) using the scaled processing times: Determine the Lagrangian ranking from the Lagrangian schedule. Preprocess the scheduling instance using the strongly ranked operation pairs, i.e., add an appropriate precedence constraint for each strongly ranked pair. Use a non-delay or an active schedule generation routine and the specified priority dispatching rule (weak ranking or ATC), and generate a feasible schedule from the preprocessed scheduling instance. This provides an upper bound for iteration r , UBr . 5.3. If the upper bound value UBr is lower than the best UB so far, then update the upper bound, UB ← min{UB, UBr }. Record its Lagrangian ranking unless the unscaled processing times option is used. If used as an option, compute the estimated dynamic adaptation potential of the current Lagrangian ranking using the feasibility restoration heuristic with unscaled processing times. If that potential is the best so far (producing the lowest estimated total weighted tardiness), then record its Lagrangian ranking. 5.4. Update scalar αr if necessary. 5.5. Compute the subgradient gkt (X r ), step size sr and update the Lagrange multipliers λrkt+1 based on Equations (33), (34) and (32), respectively. Step 6. Report the Lagrangian ranking corresponding to the best estimated performance over the K iterations. This is the Lagrangian ranking to be released to the dynamic adaptation stage. We finally summarize the overall scheduling scheme as follows: Preprocessing: 1.1. Define a JSP model using the problem instance. Lagrangian-relax the machine capacity constants, this defines N job-level subproblems (as described in Section 3.2).
1114 1.2. For each job-level subproblem, insert chance constraints based on known processing time uncertainties (as described in Section 3.3). 1.3. Solve the Lagrangian-relaxed JSP using subgradient search algorithm (Section 3.6). In each iteration, compute LB using the Lagrangian schedule, UB using the associated Lagrangian ranking, and estimate the second-stage performance of each Lagrangian ranking. 1.4 Based on the best Lagrangian schedule at the end of Step 1.3, insert precedence constraints for each strongly ranked operation pair. Dynamic adaptation: Step 2. Release the preprocessed schedule instance to the shop, generate the detailed schedule dynamically over time using the realized processing times and using the same implementation choices that are used in the preprocessing stage (see Section 3.5 for implementation choices). Note that the dynamic adaptation stage in real-time is just the application of the feasibility restoration heuristic with the best Lagrangiation ranking and the implementation choices that produce the best potential performance.
Kutanoglu and Wu Table 1. Experimental factors and their levels (each experimental treatment, factor-level combination, is run for 10 replications.) Factor
Levels
Problem size
10 × 10, 20 × 15, 30 × 10, 50 × 10 (50%), (80%) Uniform, normal Low (10%), medium (30%), high (50%)
Confidence level Distribution type Uncertainty level
4.1. Experimental design We conduct detailed computational testing on the two-stage scheduling scheme. The goal is to test the robustness of the scheme using a variety of problem instances under different implementation alternatives. We test the proposed solution methodology using Monte Carlo simulation on processing time variations. The base test problems are generated from the standard makespan job shop scheduling test set as described in Byeon et al. (1998). We use five 10 × 10 (10 jobs, 10 machines), three 20 × 15, three 30 × 10, and three 50 × 10 problems for testing. The model is coded in AMPL (Fourer et al., 1993) and solved using the dual network simplex algorithm in CPLEX (Anon, 1995). We set initial parameter values for the subgradient search algorithm as follows: λ0kt = 0 ∀k, t, and α0 = 2. We halve the value of α if there is no improvement in the Lagrangian lower bound for three consecutive iterations and set the total number of iterations K at 100 for the 10 × 10 problems, and 200 for the others. We use a common confidence value β for all chance constraints. We test two confidence levels as β = 50%, and β = 80%. Note that for both the uniform and normal distributions, the 50% confidence level corresponds to using only the mean (original) processing times whereas the 80% confidence uses the variance information in addition to the mean.
4 2 2 3
To simulate the stochastic environment, we generate realized (actual) processing times pij using two distribution types: (i) uniform: U[aij , bij ] where pij = (aij + bij )/2; and (ii) normal: N[pij , σij2 ]. Note that we assume the processing times pij specified in the scheduling data is the mean of the underlying processing time distribution. We test three levels of processing time variation (V ): 10, 30 and 50%. In the case of the uniform distribution, the range parameters are calculated as aij = pij − V p¯ and bij = pij + V p¯ where p¯ is the overall mean of the processing times. Thus, actual processing times pij are generated using a discrete uniform distribution U[aij , bij ], as V controls the range (hence the variance) of the distribution. For the normal distribution case, we equalize the variance with the uniform case, i.e. we set: (bij − aij )2 , 12 where bij and aij are derived from the uniform case with corresponding variation level V . Note that since aij and bij are calculated from the single overall mean, the variance values (for both distributions) are equal for all the operations, i.e., σij2 = σ 2 = V 2 p¯ 2 /3. We truncate negative numbers and zero generated in the implementation of these formulas to one. (Since we equate both the mean and the variance between two distributions by design, we control the Coefficient of Variation (CV), indirectly through V . In fact, the variation levels of 10, 30 and 50% correspond to CV values of 0.0577, 0.1732, and 0.2887, respectively, for both distributions. As processing times have relatively small CVs, these values are reasonable representations.) For a summary of experimental factors, see Table 1. Given a scheduling problem and the distribution information about the processing times, we use the preprocessing stage of the proposed scheme to find a partial schedule using the Lagrangian ranking. We test the robustness of the proposed scheduling scheme using Monte Carlo experiments where the processing times vary according to the specified distributions. The Monte Carlo experiment is used to simulate the performance of the selected Lagrangian ranking under 10 different realizations of the processing times. During this simulation of the dynamic adaptation stage, we use the same implementation choices that produce the reported Lagrangian ranking. At each dispatching point, the method uses the actual processing times that are known (realized) σij2 =
4. Computational study
No of levels
1115
Improving scheduling robustness up to the current point, while using the original (mean) processing times for future operations. The total weighted tardiness is reported at the end of the simulation. 4.2. The dynamic dispatching benchmark To establish a benchmark for scheduling robustness we use the ATC dynamic dispatching heuristic. As demonstrated in previous research (Byeon et al., 1998; Wu et al., 1999), dynamic dispatching heuristics such as ATC serve as an excellent benchmark since they provide consistent performance under a wide variety of shop conditions (Lawrence and Sewell, 1997; Kutanoglu and Sabuncuoglu, 2001). To provide a broader base for the benchmark, we implement four different versions of the ATC heuristic using active and non-delay schedule generation routines (Pinedo, 2001) assuming perfect and mean-value information on the processing times. In the perfect information case, we first generate the actual (after variation) processing times pij (that would be realized eventually) and make this information available for each ATC priority calculation. In the mean-value case, the ATC heuristic uses the mean processing times provided with the scheduling problem for unscheduled operations and actual processing times for scheduled operations. In both cases, the heuristic is evaluated using Monte Carlo simulation with uniform and normal processing time variations described above. In Table 2 we summarize the results of the four different ATC implementations for the 10 × 10 problems. As shown in the table, ATC appears to be quite robust under different processing time variations. The heuristic yields better performance in the normal variation case than in the uniform case at the same variation level. While non-delay ATC schedules significantly outperform their active counterparts, the difference between the overall performance of perfect and that of mean-value information is insignificant (sometimes, perfect information even leads to a poorer performance). This non-intuitive result can be explained by the fact that the ATC index makes a look-ahead approximation Table 2. Experimental results with ATC dispatching (each cell shows the average of the total weighted tardiness values over 50 instances: five 10 × 10 problems each with 10 replications) Mean-value information Variation level (%) Uniform distribution 10 30 50 Normal distribution 10 30 50
Perfect information
Active
Non-delay
Active
Non-delay
8942 8848 9418
6417 7277 8053
8509 9058 10453
6497 7224 7970
8905 8543 8374
6470 6951 7239
8865 8663 9455
6595 6767 6960
at each dispatching point using aggregated future information on each job. As a result, using mean or actual processing times may not yield significant performance difference. Based on this result, we will compare our approach with the non-delay ATC procedure that uses mean-value processing times. 4.3. Testing implementation choices To test the proposed scheme, we first compare the effects of three different implementation choices using the 10 × 10 test problems:
r Dynamic dispatching: After the Lagrangian prepossessing, complete the schedule using weak ranking or ATC ranking. (Note that this choice affects both the evaluation of the estimated performance and the upper bound calculation through the feasibility restoration heuristic. This picked alternative is also used during the simulation of the dynamic adaptation stage.) r Scheduling routine: Use active scheduling or non-delay scheduling to complete the schedule. (This again affects the evaluation of the estimated performance, the upper bound calculation and the dynamic adaptation stage.) r Processing times: Use the unscaled mean or the adjusted scaled processing times for the estimated performance. This choice affects only the estimated performance evaluation. Always use the scaled processing times for the upper bound calculation to be used in the subgradient search algorithm. Use the (unscaled) realized processing times in the simulation of dynamic adaptation stage. The above implementation choices result in eight combinations for the feasibility restoration heuristic to be used to evaluate the potential of a Lagrangian ranking. For each combination, we run the proposed procedure under different levels of β and V using 10 × 10 instances (i.e., five base problems each repeated for 10 replications for processing time variations). The results are summarized in Table 3. We first make a few observations on the implementation differences before providing more detailed analysis in subsequent sections. Results:
r Contrary to the ATC benchmark in Table 2, the active schedule generation works significantly better than the non-delay scheduling under the proposed scheme. r Among the active scheduling results, using the weak Lagrangian ranking for dynamic dispatching appears to be better than using the ATC ranking in almost all cases. Interestingly, the situation reverses among the non-delay scheduling results: ATC ranking yields a better total weighted tardiness in most cases. r Comparing the results of using scaled or unscaled processing times, we see that the results are quite similar and there is no clear dominance between either implementation.
1116
Kutanoglu and Wu
Table 3. Experimental results of the proposed methodology (each cell shows the average total weighted tardiness over 50 observations: five 10 × 10 problem instances, each simulated with 10 replications) UB calculation Dispatching Sch. routine β(%), V (%) Uniform distribution 80, 10 80, 30 80, 50 50, 10 50, 30 50, 50 Normal distribution 80, 10 80, 30 80, 50 50, 10 50, 30 50, 50
Unscaled processing times Weak ranking
Scaled processing times
ATC ranking
Weak ranking
ATC ranking
Active
Nondelay
Active
Nondelay
Active
Nondelay
Active
Nondelay
4566 5165 6627 4489 5879 8042
6327 7170 8163 6181 7694 9094
4980 5911 6959 5525 6964 9020
6015 6917 8561 6839 7650 9019
4973 5413 7714 5079 5853 7995
6186 7037 8585 7500 7908 9347
5323 6080 8011 5519 6481 8165
5722 7191 8286 6956 7772 9060
4318 5431 6013 4630 5516 6792
6557 6945 7721 6198 6865 7759
5380 6121 6737 5299 6551 7913
6110 6720 7887 6358 6738 7237
4660 5942 6590 4969 6058 7448
6839 6861 8080 6969 7517 8154
5940 5829 6283 5552 6412 7412
5869 6587 7258 7004 7129 7828
We also test several scale values (including no scaling, i.e., a scale of one) for the 10 × 10 problems. We find no significant deterioration in the performance of the proposed algorithm with substantial computational savings for increasing scale factor values. Figure 1 shows both the average CPU time per job subproblem (in seconds) and the average
total weighted tardiness values for all five 10 × 10 problems repeated 10 times under all uniform processing time variations using the proposed scheme with active scheduling and weak-ranking-based dispatching when β = 80%. The CPU times can be multiplied by 10 (10 job subproblems) to obtain the total solution time per subgradient iteration,
Fig. 1. Savings in computation time (measured in CPU seconds per job subproblem) and robustness of weighted tardiness values across different scale values when the proposed method with β = 80% is implemented under uniform processing time variation case (10 × 10 problems).
1117
Improving scheduling robustness
Fig. 2. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in uniform processing time variation case (10 × 10 problems).
and this can be multiplied by 100 (the number of iterations) to estimate how long the whole process could take. As the figure shows, the scaling of processing times brings a significant computational saving while almost no deterioration in the weighted tardiness performance. As a result of this, we set the scale factor at 10 for the 10 × 10 problems, which results in scaled processing times between one and 10. Similarly, we select scale factor values for larger problems such that the resulting scaled processing times are between one and 10. That is, we divide the adjusted processing times by a fixed value and round them to the nearest integer values to obtain scaled processing times between one and 10. We scale the due dates in a similar fashion. (For more on scaling
see Kutanoglu and Wu (2002) and Ling and Kutanoglu (2002). 4.4. Computational results Along with the 10 × 10 problems, we conduct a second set of experiments using larger sized (20 × 15, 30 × 10 and 50 × 10) test problems. In these tests, we set the weak Lagrangian ranking for dynamic dispatching, the choice of unscaled processing times for estimating the performance, and the active scheduling routine for schedule generation. Along with the 10 × 10 results in Table 3, we plot the performance of this specific implementation in Figs. 2–9 grouped by problem size and distribution type.
Fig. 3. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in normal processing time variation case (10 × 10 problems).
1118
Kutanoglu and Wu
Fig. 4. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in uniform processing time variation case (20 × 15 problems).
4.4.1. The effect of confidence levels Intuitively, the preprocessing strategy that uses the secondmoment information of processing time variation should be more robust than the ones that use only expected values. We test this intuition by comparing the 80 and 50% confidence levels (β) used to characterize the chance constraints. Recall that in the 80% confidence case both the mean and the variance of processing time variations are used in the preprocessing stage. As the results in Table 3 show, in 85.4% (or 41 out of 48) of the cases the 80% confidence level yields a significantly lower (an average of 9.7%) weighted tardiness
when compared to the 50% confidence level. The results also show that the value of the second moment information increases as the level of variation increases. As can be computed from Table 3, in the high uncertainty (V = 50%) cases, the algorithm benefits from the use of the variance information much more frequently than the low uncertainty (V = 10%) cases (94% compared to 69%). However, the average amount of improvement is roughly the same (10.8% compared to 10.2%). Furthermore, the value of the secondmoment information is affected by the type of distribution. It yields a performance improvement of up to 29.6% (11.3%
Fig. 5. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in normal processing time variation case (20 × 15 problems).
Improving scheduling robustness
1119
Fig. 6. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in uniform processing time variation case (30 × 10 problems).
average) in the uniform cases, and up to 19.3% (7.8% average) in the normal cases. The effect of using the second-moment information is depicted in Figs. 2 and 3. As the graphs show, the 80% confidence level draws the lower envelope in both distribution types and in all variation levels. Corresponding plots for larger-sized problems in Figs. 4–9 also show the secondmoment information significantly improves scheduling robustness. The figures also show that the performance
improvement due to the 80% confidence level is more pronounced in the uniform distribution cases. 4.4.2. The effect of a priori analysis on dynamic dispatching Using the experimental results, we can also test if the performance of dynamic dispatching such as ATC can be significantly improved by a priori analysis using stochastic information. We compare the results from straight-forward ATC dispatching (Table 2) and ATC dispatching after
Fig. 7. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in normal processing time variation case (30 × 10 problems).
1120
Kutanoglu and Wu
Fig. 8. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in uniform processing time variation case (50 × 10 problems).
the Lagrangian preprocessing (i.e., ATC ranking for dynamic dispatching in Table 3). As shown in the tables, if the Lagrangian preprocessing with ATC is implemented using β = 80% and active schedule generation, the proposed scheme significantly outperforms straightforward non-delay ATC dispatching under all levels of uncertainty in all test cases (an average of 34% improvement, ranging from 7 to 80%). Figures 2–9 show graphically the performance of this preprocessing scheme (with and without the variance information) as compared to the non-delay
ATC heuristic. As the graphs show, the performance of the Lagrangian preprocessing with the weak ranking option clearly dominates that of ATC. The improvement, however, varies depending on the level of uncertainty, problem size, and the underlying distribution. 4.4.3. The effect of variation level and distribution-type We investigate if the marginal benefit of a priori stochastic information increases when the variation level increases.
Fig. 9. Average weighted tardiness plotted against uncertainty level for selected PFSL settings in normal processing time variation case (50 × 10 problems).
1121
Improving scheduling robustness
Fig. 10. Effects of surrogate scheme ( = 100) on PFSL algorithm (uniform processing time variation case, 20 × 15 problems).
Figures 2–9 show that whereas the performance of ATC and 50% confidence preprocessing deteriorate rapidly as the level of uncertainty increases, 80% confidence preprocessing does not deteriorate as quickly. This supports the conjecture that preprocessing has increasing importance as the level of uncertainty increases. Furthermore, we see that all methods are more sensitive to the uncertainty levels under uniform distribution. If we compare the results between the uniform and the normal cases in Table 3, we find that 71% of the time (or 34 out of 48 cases) the preprocessing algorithm achieves better performance under the uniform distribution than the normal distribution.
4.4.4. Remarks on due date tightness As the results presented in the previous sections show, problem instances do affect the performance of the proposed scheme. When we test the 20 × 15 problem instances, we find that during the preprocessing stage, the Lagrangian relaxation lower bound does not improve over 200 subgradient iterations. Further investigation reveals that this is the result of relatively loose due dates, where the subgradient search algorithm does not have the needed subgradient information to improve the bounds as the corresponding LP relaxation’s bound is always zero for all problems in this set. To address this issue, we solve a surrogate Lagrangian relaxation problem during the preprocessing phase. The
Fig. 11. Effects of surrogate scheme ( = 100) on PFSL algorithm (normal processing time variation case, 20 × 15 problems).
1122 surrogate problem is created by subtracting a fixed value from the original due dates for the Lagrangian-relaxed problem. At the end of the subgradient search, we use the established Lagrangian ranking (both strong and weak ranking) as before, but we use the original due dates for estimating the performance of Lagrangian rankings and during the dynamic adaptation simulation. With this simple scheme, we successfully overcome this problem during the subgradient search. Figures 10 and 11 show the results of this set of experiments for 20 × 15 problems. As the graphs depict, the surrogate scheme significantly improves the performance of the preprocessing algorithm. All 20 × 15 results shown in earlier sections correspond to this improved version.
4.4.5. Remarks on Lagrangian rankings and dynamic adaptation To further evaluate the solution quality of the proposed scheme, we conduct experiments with a small set of problems that can be solved to optimality. We consider five 6 × 6 (six jobs, six machines) example problems, all of which are derived randomly from the original 6 × 6 problem in Muth and Thompson (1963). Each problem is an instance of the classical job shop problem. The mean operation processing times are integers randomly chosen between one and 10, i.e., U [1,10]. The weight of each job is again an integer drawn from the discrete uniform distribution U [1,10]. The due date for each job is randomly assigned to give a maximum flow allowance of 10 + 1.2x(total mean job processing time). Using this method, we produce five problems with quite variable due dates yielding one to six tardy jobs, changing depending on the realizations of processing times.
Kutanoglu and Wu For these experiments, we run the algorithm with the same implementation choices as before (however, with no scaling as it is not needed). We simulate the realized performances of the best Lagrangian rankings produced within 60 iterations of the subgradient search algorithm in 10 realizations (replications) of processing time variation with uniform distribution. We solve each of these realized scenarios optimally to see what the performance could be if their processing time information were all known (perfect information, we denote this as OPT). We also solve each scenario under the so-called “forced Lagrangian ranking” setting with perfect information, where the Lagrangian ranking among jobs is enforced with additional job-based precedence constraints in the realized scenarios (denoted as Forced Ranking OPT). Figure 12 shows the performances of all the previous contenders (non-delay ATC, β = 80% and β = 50%) relative to these two additional benchmarks over three variation levels (each point shows the average of five problems multiplied by 10 replications which equals 50 total “instances”). We find that the average percentage difference between β = 80% and OPT is 4.96% (with a minimum of 0% and a maximum of 13.75% across instances) at 10% variation, 6.93% (with a range of [0,26.11%]) at 30% variation, and 9.47% (with a range of [0,28.54%]) at 50% variation. Hence, the performance of the proposed scheme that produces one Lagrangian ranking to be used under all scenarios is not too far from the “perfect information optimal” which customizes the whole schedule for each scenario. The figure also shows the benefit of dynamic adaptation, as the proposed approach (with either confidence level) is better than the optimal performance of the enforced Lagrangian ranking. We also observe that the improvement increases as the variation level increases. The main contribution of dynamic adaptation is the possibility
Fig. 12. Average weighted tardiness plotted against uncertainty level for selected PFSL settings and optimal schedules in the uniform processing time variation case (6 × 6 problems).
1123
Improving scheduling robustness
Fig. 13. Average “similarity” percentage between Lagrangian rankings (before and after dynamic adaptation, using β = 80%) and the resulting rankings from optimal schedules in the uniform processing time variation case (6 × 6 problems).
to process a lower-ranked job before a higher-priority job if the latter is not available in a short time period when it is time to pick the next job to process on a machine. Hence, this shows once more that a “fixed” schedule may perform poorly under stochastic conditions, and the proposed approach is able to pull the performance closer to the perfect information optimal, outperforming both the dynamic ATC and the fixed schedule. Finally, we analyze the “similarity” between the Lagrangian ranking and the sequence in the optimal schedules. We compare the Lagrangian ranking reported at the end of the subgradient search algorithm (using β = 80%) with the individual optimal schedule found for each “instance” at each variation level for each problem. To “measure” the overall similarity between the Lagrangian ranking and the optimal ranking, we ask the following question for each pair of jobs i and i (i > i) at each machine k: does the Lagrangian ranking between jobs i and i agree with the sequence established in the optimal solution? For a 6 × 6 problem, we ask 15 such questions for each machine and 90 questions in total for each realization of the instances and record the number of “yes” answers. We further distinguish the comparisons before the dynamic adaptation phase takes place (before Dynamic Adaptation (DA)), and after (after DA). The results are shown in Fig. 13. The figure not only shows that the Lagrangian and optimal rankings “agree” on ordering jobs 87.5 to 92% of the time, but also that the dynamic adaptation (on average) makes the Lagrangian ranking somewhat “closer” to the optimal sequencing.
5. Conclusions We develop a PFSL scheduling scheme that combines stochastic analysis with dynamic adaptation to improve the robustness for the JSP. The extensive computational testing using a variety of problem sizes supports that the proposed approach successfully combines the benefits of both dynamic and static scheduling and that it provides highly robust performance under various experimental conditions. We show that both stochastic analysis and dynamic adaptation are important in improving scheduling robustness. Making use of the second-moment information achieves further improvement in most cases. Moreover, the benefits of preprocessing appear to be more significant in larger problem instances at higher levels of uncertainty. This suggests that the proposed scheme would be of value in a practical setting. The method is shown to be more robust than static optimization schemes, while significantly outperforming best known dynamic heuristics in both performance and robustness.
Acknowledgements This research has been supported, in part, by National Science Foundation Grants DMI-9634808, DMI-0075391, and DMI-0121395. We also thank the anonymous referees and the associate editor for their comments that improved the original version of this paper.
1124 References Anon (1995) Using the CPLEX base system including CPLEX mixed integer solver and barrier solver options, IL06 Inc. Baptiste, P. and Favrel, J. (1993) Taking into account the rescheduling problem during the scheduling phase. Production Planning and Control, 4, 349–360. Bean, J.C., Birge, J.R., Mittenthal, J. and Noon, C.E. (1991) Matchup scheduling with multiple resources, release dates and disruptions. Operations Research, 39(3), 470–483. Byeon, E.S., Wu, S.D. and Storer, R.H. (1998) Decomposition heuristics for robust job-shop scheduling. IEEE Transactions on Robotics and Automation, 14(2), 303–313. Charnes, A. and Cooper, W.W. (1959) Chance-constrained programming. Management Science, 6, 73–79. Church, L.K. and Uzsoy, R. (1992) Analysis of periodic and eventdriven rescheduling policies in dynamic shops. International Journal of Computer Integrated Manufacturing, 5, 153–163. Fourer, R., Gay, D.M. and Kernighan, B.W. (1993) AMPL: A Modeling Language for Mathematical Programming. Boyd and Fraser Publishing Company, Danvers, MA. Gallego, G. (1988a) Linear control policies for scheduling a single facility after an initial disruption. Technical Report 770, Cornell University, Ithaca, NY. Gallego, G. (1988b) Produce-up-to policies for scheduling a single facility after an initial disruption. Technical report 771, Cornell University, Ithaca, NY. Kouvelis, D. and Yu, G. (1996) Robust Discrete Optimization and Its Applications, Kluwer, Boston, MA. Kutanoglu, E. and Sabuncuoglu, I. (2001) Experimental investigation of iterative simulation-based scheduling in dynamic and stochastic job shops. Journal of Manufacturing Systems, 20(4), 264–279. Kutanoglu, E. and Wu, S.D. (2002) Scaling-based heuristics for job shop scheduling under deterministic and stochastic conditions. Technical report, Operations Research and Industrial Engineering Program, Department of Mechanical Engineering, The University of Texas at Austin, Austin, TX. Lawrence, S.R. and Sewell, E.C. (1997) Heuristic, optimal, static, and dynamic schedules when processing times are uncertain. Journal of Operations Management, 15, 71–82. Leon, V.J., Wu, S.D. and Storer, R.H. (1994) Robustness measures and robust scheduling. IIE Transactions, 26(5), 32–43. Ling, R. and Kutanoglu, E. (2002) A scaling-based heuristic for resourceconstrained project scheduling problems. Technical report, Operations Research and Industrial Engineering Program, Department of Mechanical Engineering, The University of Texas, Austin, TX. Maddox, M.J. and Birge, J.R. (1992) Using second moment information in stochastic scheduling, in Recent Advances in Control and Optimization of Manufacturing Systems, Yin, G. and Zhang, Q. (eds.), Springer-Verlag, pp. 99–120. Mehta, S.V. and Uzsoy, R. (1997) Predictable scheduling of a job-shop subject to breakdowns. IEEE Transactions on Robotics and Automation, 14, 149–156. Morton, T.E., Lawrence, S., Rajagopalan, S. and Kekre, S. (1986) MRPSTAR PATRIARCH’s planning module. Working paper, Graduate School of Industrial Administration, Carnegie Mellon University, Pittsburgh, PA. Morton, T.E., Lawrence, S., Rajagopalan, S. and Kekre, S. (1988) A pricebased shop scheduling module. Working paper, Graduate School of Industrial Administration, Carnegie Mellon University, Pittsburgh, PA. Muhlemann, A.P., Lockett, A.G. and Farn, C.K. (1982) Job shop scheduling heuristic and frequency of scheduling. International Journal of Production Research, 20(2), 227–241.
Kutanoglu and Wu Muth, J.F. and Thompson, G.L. (1963) Industrial Scheduling, Prentice Hall, Englewood Cliffs, NJ. Parker, R.G. and Rardin, R.L. (1988) Discrete Optimization, Academic Press, San Diego, CA. Pinedo, M. (2001) Scheduling: Theory, Algorithms and Systems, 2nd edn., Prentice Hall, Englewood Cliffs, NJ. Pritsker, A., Watters, L. and Wolfe, P. (1969) Multiproject scheduling with limited resources: a zero-one programming approach. Management Science: Theory, 16(1), 93–108. Roundy, R.O., Maxwell, W.L., Herer, Y.T., Tayur, S.R. and Getzler, A.W. (1991) A price-directed approach to real-time scheduling of production operations. IIE Transactions, 23(2), 149–160. Vepsalainen, A.P.J. and Morton, T.E. (1987) Priority rules for job shops with weighted tardiness costs. Management Science, 33(8), 1035– 1047. Wolsey, L.A. (1998) Integer Programming, J Wiley, New York, NY. Wu, S.D., Byeon, E.S. and Storer, R.H. (1999) A graph-theoretic decomposition of the job shop scheduling problem to achieve scheduling robustness. Operations Research, 47(1), 113–124. Wu, S.D., Storer, R.H. and Chang, P.C. (1992) A rescheduling procedure for manufacturing systems under random disruptions, in New Directions for OR in Manufacturing, Springer-Verlag. Wu, S.D., Storer, R.H. and Chang, P.C. (1993) One machine rescheduling heuristics with efficiency and stability as criteria. Computers & Operations Research, 20, 1–14. Yamamoto, M. and Nof, S.Y. (1985) Scheduling/rescheduling in the manufacturing operating system environment. International Journal of Production Research, 23(4), 705–722.
Biographies Erhan Kutanoglu is an Assistant Professor in the Operations Research and Industrial Engineering Graduate Program in the Department of Mechanical Engineering at The University of Texas at Austin. Before his current position, he worked as an Operations Research Analyst and Development Engineer at IBM Global Services, and as an Assistant Professor of Industrial Engineering at the University of Arkansas. He received his Ph.D. in Industrial Engineering at Lehigh University in 1999, and his M.S. and B.S. degrees, both in IE, at Bilkent University, Turkey. His current research interests include large-scale logistics and supply chain optimization; scalable, distributed, and game-theoretic models and algorithms with applications to scheduling, inventory, logistics network design, and supply chain problems. His research has been supported by the National Science Foundation, the Defense Logistics Agency, and corporations such as IBM and Dell. He is a 2002 recipient of the NSF Faculty Early Career Development (CAREER) Award. He is a member of IIE, INFORMS, SME and ASEE. S. David Wu is the Lee A. Iacocca Professor and Chairman of the Department of Industrial and Systems Engineering at Lehigh University. His research interests are in the areas of supply chain analysis, distributed and game theoretic decision processes, and combinatorial optimization. He has published extensively in these areas, in journals such as IIE Transactions, Operations Research, Management Science, and IEEE Transactions. His research has been supported by the NSF, DOD, Sandia National Laboratory and major corporations such as Agere Systems, Lucent Technologies, UNISYS and Bethlehem Steel. He serves as a Department Editor for the IIE Transactions and is on the Editorial Boards of M&SOM, IEEE Transactions on Robotics and Automation, and Journal of Manufacturing Systems. He received his M.S.I.E. and Ph.D. degrees from the Pennsylvania State University in 1987. In 1995–1996, he was a visiting professor at University of Pennsylvania.
